# -*- coding: utf-8 -*-
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.views import password_reset
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User, Group, Permission
from django.core.mail import send_mail, EmailMessage
from django.http import HttpResponse, Http404, HttpResponseRedirect
from django.shortcuts import render, render_to_response, redirect
from django.template import Context, RequestContext, loader
from django.views.decorators.csrf import csrf_exempt
from django_countries.countries import COUNTRIES
from indicadores.models import IndicadoresBooleanos, IndicadoresEnteros, IndicadoresBooleanos, IndicadoresEnteros, IndicadoresPorcentaje, IndicadoresChoices, RespuestaBooleanos, RespuestaEnteros, \
    RespuestaPorcentaje, RespuestaChoices, RespuestaTexto, IndicadoresPorcentaje, IndicadoresChoices, RespuestaBooleanos, RespuestaEnteros, RespuestaPorcentaje, RespuestaChoices, RespuestaTexto
from informes_institucionales.models import InformeInstitucional
from universidades.form import RegistroUnivForm, RegistroUserForm, RegistroUnivFormUserValid
from universidades.models import Universidad, Region, Pais_region, Universidad, Universidad_temp, Region, Pais_region
from usuarios.models import Usuario
from validaciones.models import checkpermiso, checkuniversidad, getAdminIns, respuestahttp, Validacion, checkpermiso, checkuniversidad, getAdminIns, respuestahttp, Validacion
from django.utils import simplejson
from smtplib import SMTPRecipientsRefused
import re

# agregar autenticacion de usuarios a los reportes
Permisos = ['validaciones.Ver_reportes']  # para verificar en los reportes
Permisos2 = ['validaciones.Participantes_Publico']  # para verificar en los participantes


#********************************************************user*******************************************************
def admin_user( request, identificador = -1 ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''

        if 'message' in request.GET:
            message = request.GET['message'].split( '/' )[0]
            tipo = request.GET['message'].split( '/' )[1]
            if tipo == "exito":
                show_message_success = True
                mensaje_exito += message
            elif tipo == "error":
                show_message_error = True
                mensaje_error += message

        if( identificador != -1 ):
            try:
                user = User.objects.get( id = identificador )
                region = Region.objects.filter(administrador_id = identificador)
                universidad = Universidad.objects.filter(administrador_id = identificador)
                #PAra eliminar al usuario verificamos que no sea administrador de ninguna universidad y/o región.
                if (len(universidad) == 0) and (len(region) == 0):
                    User.objects.filter( id = identificador ).delete()
                    # envio de mail informando al usuario que sido eliminado del sistema

                    #######if not u.groups.filter( name = 'Adm. Regional' ).exists():
                    # asunto = 'Baja de la plataforma'
                    # mensaje = 'Su usuario ha sido dado de baja de la plataforma Vincula Entorno.\n\nEquipo Vincula Entorno.'
                    # recipients = [unicode( user.email )]
                    # correo = EmailMessage( asunto, mensaje, 'evincula@gmail.com', recipients, [], headers = {} )
                    # correo.send()
                    asunto = 'Baja de la plataforma'
                    mensaje = 'Su usuario ha sido dado de baja de la plataforma Vincula Entorno.\n\nEquipo Vincula Entorno.'
                    recipients = [unicode( user.email )]
                    send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)

                    show_message_success = True
                    show_message_error = False
                    mensaje_exito += "<p><strong>El borrado ha sido exitoso!!</strong>"
                else:
                    mensaje_error += "<p><strong>No se ha podido eliminar al usuario por las sgtes razones:</strong>"
                    if len(universidad) != 0:
                        show_message_success = False
                        show_message_error = True
                        mensaje_error += "<p>* El usuario es administrador de una universidad. Debe realizar el traspaso de mando antes de eliminarlo."
                    if len(region) != 0:
                        show_message_success = False
                        show_message_error = True
                        mensaje_error += "<p>* El usuario es administrador de una región. Debe realizar el traspaso de mando antes de eliminarlo."
            except Exception, e:
                show_message_error = True
                show_message_success = False
                mensaje_error += "<strong>Error!</strong>Ha ocurrido un problema con el borrado. Intente de nuevo.<p><strong>Captura del error:</strong><p>" + str( e )


        menu = sidebar( request )
        user = User.objects.all()
        mtx = {'usuario':user,
        'menu' : menu,
        'show_message_success': show_message_success,
        'show_message_error': show_message_error,
        'mensaje_error':mensaje_error,
        'mensaje_exito':mensaje_exito}
        mtx = desplegar_indicadores_user( mtx )
        context_instance = RequestContext( request )
        return render_to_response( 'admin_user.html', mtx, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def agregar_user( request ):
    if request.user.is_staff:  # solo si tiene permiso de Staff
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''
        if request.method == 'POST':
            # POST del formulario agregar_user
            correo = unicode( request.POST['correo'] )
            nombrePropio = unicode( request.POST['nombrePropio'] )
            apellidos = unicode( request.POST['apellidos'] )
            universidad_id = request.POST['universidad']

            # inicializamos variables
            nombreUniversidad = ''
            cod_pais = ''
            cod_ciudad = ''
            telefono = ''
            password = ''
            url = ''
            confirm = ''
            siglas = ''
            direccion = ''
            pais = ''
            banderaAdministradorUserCheck = ''
            banderaFormularioUniversidad = ''

            # Preguntamos si estos valores se encuentran en el post. Pueden o no existir, puesto que no todos los campos
            # son requeridos en el formulario
            if 'banderaFormularioUniversidad' in request.POST:
                banderaFormularioUniversidad = request.POST['banderaFormularioUniversidad']  # si se activo el formulario para crear una universidad

            if 'banderaAdministradorUserCheck' in request.POST:
                banderaAdministradorUserCheck = request.POST['banderaAdministradorUserCheck']  # si como administrador de la universidad creada fue

            if 'pass' in request.POST:
                    password = unicode( request.POST['pass'] )
            if 'confirm' in request.POST:
                    confirm = unicode( request.POST['confirm'] )

            if 'user_id' in request.POST:
                user_id = request.POST['user_id']

            if 'activo' in request.POST:
                if request.POST['activo'] == "on":
                    activo = 1
            else:
                activo = 0  # off

            if 'staff' in request.POST:
                if request.POST['staff'] == "on":
                    staff = 1
            else:
                staff = 0  # off

            if 'superuser' in request.POST:
                if request.POST['superuser'] == "on":
                    superuser = 1
            else:
                superuser = 0  # off

            ##########################################Verificamos el formulario##############################################################
            # ##Verificamos que los campos Required, no vengan vacios
            if correo == '':
                mensaje_error += "<p>El campo correo no debe estar vacío."
            elif ( User.objects.filter( username = unicode( correo ) ).exists() ):
                mensaje_error += "El correo ingresado ya existe. Ingrese uno diferente."
            elif not( re.match( r"^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$", correo ) ):
                mensaje_error += "Verifique el formato del correo ingresado."

            if password == '':
                mensaje_error += "<p>El campo password no debe estar vacío."
            if confirm == '':
                mensaje_error += "<p>El campo confirmación no debe estar vacío."
            if banderaFormularioUniversidad == '0' and universidad_id == '':  # si no se activo el formulario para crear universidad, si o si debe elegirse una universidad para asignar al usuario
                mensaje_error += "<p>Debe asignar una universidad al usuario, o bien, crear la nueva universidad."
            if banderaFormularioUniversidad == '1':  # si se activo el form para crear universidad, controlar los campos required
                nombreUniversidad = unicode( request.POST['nombreUniv'] )
                url = request.POST['url']
                pais = request.POST['pais']
                administrador_id = ''
                if 'administrador' in request.POST:
                    administrador_id = request.POST['administrador']

                if  nombreUniversidad == '':
                    mensaje_error += "<p>El campo nombre de universidad no debe estar vacío."
                if url == '':
                    mensaje_error += "<p>El campo URL no debe estar vacío."
                elif ( Universidad.objects.filter( url = unicode( url ) ).exists() ):  # se verifica que la url ingresada no esté duplicada
                    mensaje_error += "La URL ingresada ya existe. Ingrese uno diferente."
                elif not( re.match( r"^((http:\/\/www\.|https:\/\/www\.|www\.)[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*\.[a-zA-Z]{2,6}(?:\/?|(?:\/[\w\-]+)*)(?:\/?|\/\w+\.[a-zA-Z]{2,4}(?:\?[\w]+\=[\w\-]+)?)?(?:\&[\w]+\=[\w\-]+)*)$", url ) ):
                    mensaje_error += "Verifique el formato de la url."

                if pais == '':
                    mensaje_error += "<p>Se debe seleccionar un país para la universidad."
                if banderaAdministradorUserCheck == '0' and administrador_id == '':  # si no se seleccionó el check para asignar al usuario recien creado como administrador de la universidad, se tiene que seleccionar
                                                                                    # un administrador de la lista
                    mensaje_error += "<p>Se debe seleccionar un administrador para la universidad, o bien, asignar a este usuario como administrador."
            if password != '' and confirm != '':  # si estos campos no vienen vacio, hay que verificar que coincidan.
                if password != confirm:
                    mensaje_error += "<p>El password y la confirmación deben coincidir."

            if mensaje_error != '':  # si hubo algun error, volvemos a la pagina Agregar_User, para corregir dichos errores
                show_message_error = True  # ocurrio errores
                universidades = Universidad.objects.all()
                users = User.objects.all();
                usuarios = []
                admin_id = []

                for user_temp in users:
                    usuarios.append( user_temp )
                    admin_id.append( user_temp.id )

                for universidad_temp in universidades:
                    temp = User.objects.get( id = universidad_temp.administrador_id )
                    usuarios.remove( temp )
                    admin_id.remove( universidad_temp.administrador_id )

                usuarios_sinc = zip( admin_id, usuarios )
                menu = sidebar( request )
                lista_sinc_paises = listarPaises( modelo = "Pais_region" )
                mtx = {'usuarios': usuarios_sinc,
                'universidades':universidades,
                'lista_sinc_paises':lista_sinc_paises,
                'menu' : menu,
                'show_message_success': show_message_success,
                'show_message_error': show_message_error,
                'mensaje_error':mensaje_error,
                'mensaje_exito':mensaje_exito
                }
                context_instance = RequestContext( request )
                return render_to_response( 'agregar_user.html', mtx, context_instance = context_instance )

            ###################################FIN DE LAs VERIFICACIONES##############################################################
            # agregamos al user
            respuesta = User( username = correo, email = correo, first_name = nombrePropio, last_name = apellidos, is_staff = staff, is_active = activo, is_superuser = superuser )
            respuesta.set_password( password )
            try:
                respuesta.save()
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

             # creamos la nueva universidad
            if banderaFormularioUniversidad == '1':  # si se creo una universidad, recuperamos los datos de ese formulario
                # campos obligatorios
                nombreUniversidad = unicode( request.POST['nombreUniv'] )
                pais = request.POST['pais']
                region = Pais_region.objects.get( pais = pais );

                # campos que pueden o no venir con datos
                if 'telefono' in request.POST:
                    telefono = unicode( request.POST['telefono'] )

                if 'cod_pais' in request.POST:
                    cod_pais = unicode( request.POST['cod_pais'] )

                if 'cod_ciudad' in request.POST:
                    cod_ciudad = unicode( request.POST['cod_ciudad'] )

                if 'siglas' in request.POST:
                    siglas = unicode( request.POST['siglas'] )
                if 'direccion' in request.POST:
                    direccion = unicode( request.POST['direccion'] )
                if 'administrador' in request.POST:
                    administrador_id = request.POST['administrador']

                if banderaAdministradorUserCheck == '1':
                    administrador = User.objects.get( username = correo )
                    administrador_id = administrador.id

                telefono_completo = cod_pais + "-" + cod_ciudad + "-" + telefono  # telefono con los codigos respectivos

                #***parseamos la url para obtener solo la parte del www...
                url_aux = url.split( '//' )
                if len( url_aux ) == 1:  # la url ingresada es del tipo www... entonces se le pasa ese valor del vector en [0]
                    url = url_aux[0]
                elif len( url_aux ) == 2:  # la url ingresada es del tipo http://www... o https://www..., por eso le pasamos el segundo valor del vector ([1]) al hacer el split, que seria la parte del wwww..
                    url = url_aux[1]
                
                #***Guardamos la nueva universidad
                respuesta = Universidad( nombre = nombreUniversidad, telefono = telefono_completo, url = url, pais = pais, direccion = direccion, siglas = siglas, region_id = region.region_id, administrador_id = administrador_id )
                try:
                    respuesta.save()
                except Exception, e:
                    return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )
                
                universidad_aux = Universidad.objects.get( nombre = nombreUniversidad )  # traemos la nueva universidad guardada para guardarla luego con su usuario

                #*****al administrador de la universidad lo agregamos a userGroup como adm. institucional
                g = Group.objects.get( name = 'Adm. Institucional' )
                g.user_set.add( administrador_id )

            else:  # traemos la universidad seleccionada
                universidad_aux = Universidad.objects.get( id = universidad_id )

            user = User.objects.get( email = correo )  # traemos al user recien creado

            # agregamos al usuario (user con su universidad)
            usuario = Usuario( user = user, universidad = universidad_aux )
            usuario.save()

            return redirect( '/plataforma/universidades/admin_user/' + "?message=El user ha sido agregado con exito./exito" )
        # endif POST

        universidades = Universidad.objects.all()
        users = User.objects.all();
        usuarios = []
        admin_id = []

        for user_temp in users:
            usuarios.append( user_temp )
            admin_id.append( user_temp.id )

        for universidad_temp in universidades:
            temp = User.objects.get( id = universidad_temp.administrador_id )
            usuarios.remove( temp )
            admin_id.remove( universidad_temp.administrador_id )

        usuarios_sinc = zip( admin_id, usuarios )
        menu = sidebar( request )
        lista_sinc_paises = listarPaises( modelo = "Pais_region" )
        mtx = {'usuarios': usuarios_sinc,
        'universidades':universidades,
        'lista_sinc_paises':lista_sinc_paises,
        'menu' : menu,
        'show_message_success': show_message_success,
        'show_message_error': show_message_error,
        'mensaje_error':mensaje_error,
        'mensaje_exito':mensaje_exito
        }
        context_instance = RequestContext( request )
        return render_to_response( 'agregar_user.html', mtx, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def edicion_user( request, user_id ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''
        if request.method == 'POST':
            user_id = request.POST['user_id']
            correo = unicode( request.POST['correo'] )  # el nuevo correo que pudo haber sido escrito
            correo_antesEdicion = unicode( request.POST['email'] )  # el email original del user
            nombrePropio = unicode( request.POST['nombrePropio'] )
            apellidos = unicode( request.POST['apellidos'] )
            universidad_id = request.POST['universidad']

            nombreUniversidad = ''
            password = ''
            pais = ''

            if 'pass' in request.POST:
                    password = unicode( request.POST['pass'] )

            if 'activo' in request.POST:
                if request.POST['activo'] == "on":
                    activo = 1
            else:
                activo = 0  # off

            if 'staff' in request.POST:
                if request.POST['staff'] == "on":
                    staff = 1
            else:
                staff = 0  # off

            if 'superuser' in request.POST:
                if request.POST['superuser'] == "on":
                    superuser = 1
            else:
                superuser = 0  # off

            ##########################################Verificamos el formulario##############################################################
            # ##Verificamos que los campos Required, no vengan vacios
            if correo == '':
                mensaje_error += "<p>El campo correo no debe estar vacío."
            elif ( ( correo != correo_antesEdicion ) and ( User.objects.filter( username = unicode( correo ) ).exists() ) ):
                mensaje_error += "El correo ingresado ya existe. Ingrese uno diferente."
            elif not( re.match( r"^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$", correo ) ):
                mensaje_error += "Verifique el formato del correo ingresado."

            if universidad_id == '':
                mensaje_error += "<p>El user debe estar asociado a una universidad."

            if mensaje_error != '':  # si hubo algun error, volvemos a la pagina Edicion_User, para corregir dichos errores
                show_message_error = True  # ocurrio errores
                user = User.objects.get( id = user_id )
                universidades = Universidad.objects.all()
                usuario = Usuario.objects.get( user = user )
                user_universidad_id = usuario.universidad_id

                email = user.email
                username = user.username
                first_name = user.first_name
                last_name = user.last_name
                staff = user.is_staff
                active = user.is_active
                superuser = user.is_superuser
                menu = sidebar( request )
                mtx = {'user_universidad_id':user_universidad_id,
                    'universidades':universidades,
                    'identificador':user_id,
                    'email' : email,
                    'username' : username,
                    'first_name' : first_name,
                    'last_name' : last_name,
                    'staff' : staff,
                    'active' : active,
                    'superuser' : superuser,
                    'menu' : menu,
                    'show_message_success': show_message_success,
                    'show_message_error': show_message_error,
                    'mensaje_error':mensaje_error,
                    'mensaje_exito':mensaje_exito
                    }
                context_instance = RequestContext( request )
                return render_to_response( 'edicion_user.html', mtx, context_instance = context_instance )
            ##########################################FIN de las verificaciones##############################################################

            user = User.objects.get( id = user_id )
            
            # se cargan los datos modificados al user
            user.first_name = nombrePropio
            user.last_name = apellidos
            user.username = correo
            user.is_staff = staff
            user.is_active = activo
            user.is_superuser = superuser
            user.email = correo
            if password != '':  # setear nuevo password
                user.set_password( password )

            try:
                user.save()  # Se guarda el usuario
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            #**************modificar la tabla usuario_usuario*******************
            universidad_aux = Universidad.objects.get( id = universidad_id )
            # eliminamos el registro actual del usuario en la tabla usuario+_usuario
            Usuario.objects.filter( user = user ).delete()
            # agregamos al usuario (user con su universidad). NUEVA ASOCIACION
            usuario = Usuario( user = user, universidad = universidad_aux )
            usuario.save()

            return redirect( '/plataforma/universidades/admin_user/' + "?message=El user ha sido editado con exito./exito" )
        # endif POST


        user = User.objects.get( id = user_id )
        universidades = Universidad.objects.all()
        usuario = Usuario.objects.get( user = user )
        user_universidad_id = usuario.universidad_id

        email = user.email
        username = user.username
        first_name = user.first_name
        last_name = user.last_name
        staff = user.is_staff
        active = user.is_active
        superuser = user.is_superuser
        menu = sidebar( request )
        mtx = {'user_universidad_id':user_universidad_id,
            'universidades':universidades,
            'identificador':user_id,
            'email' : email,
            'username' : username,
            'first_name' : first_name,
            'last_name' : last_name,
            'staff' : staff,
            'active' : active,
            'superuser' : superuser,
            'menu' : menu,
            'show_message_success': show_message_success,
            'show_message_error': show_message_error,
            'mensaje_error':mensaje_error,
            'mensaje_exito':mensaje_exito
            }
        context_instance = RequestContext( request )
        return render_to_response( 'edicion_user.html', mtx, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def desplegar_indicadores_user( mx ):
    lista = '<table border = "0" class="table table-striped" width = "100%">'
    lista = lista + '<tr><th align = "center" width = "50%"><b>Nombre del user</b></th><th align = "center" width = "50%" colspan="3"><b>Opciones</b></th></tr>'
    
    if len(mx['usuario']) <= 2: #mayor a 2 porque si o si existen admin y anonimo, otro aparte de ellos seria ya un usuario normal
        lista = lista + '<tr><td><i>No existen usuarios en el sistema.</i></td></tr>'
    else:
        for user in mx['usuario']:
            if user.username == 'admin' or user.username == 'Anonimo':  # para quitar a estos dos usuarios de la lista de user en admin_user
                continue
            else:
                lista = lista + '<tr><td align = "center" width = "40%">' + unicode( user.username ) + '</td>'
                lista = lista + '<td align = "center" width = "5%"><a class="btn btn-primary" onClick="javascript:verDatos(' + unicode(user.id) + ')">Ver &raquo</a></td>'
                lista = lista + '<td align = "center" width = "5%"><a class="btn btn-primary" href="/plataforma/universidades/edicion_user/' + unicode( user.id ) + '"> Editar &raquo</a></td><td align = "center" width = "5%"><a class="btn btn-primary" onClick="javascript:eliminar(' + unicode( user.id ) + ')">Eliminar &raquo</a></td></tr>'

    lista = lista + '</table>'
    mx.update( {'lista':lista} )
    return mx

#******************************************************envioMailAlBorrarUniversidad**********************************************
# SALIDA - cada i es una universidad asociada a una region dada.
#----------------------------------------------------------------
#   mensaje_universidad[i][0] = "nombreUniversidad", 
#   mensaje_universidad[i][1] = "usuarios asociados a la univ 'nombreUniversidad' posiblemente administradores de otra univ", 
#   mensaje_universidad[i][2] = "usuarios asociados a la univ 'nombreUniversidad' posiblemente administradores de alguna region"
#********************************************************************************************************************************
def envioMailAlBorrarUniversidad( identificador, tipoBorrado ):
    mensaje_usuarios_regional = []
    mensaje_usuarios_institucional = []
    mensaje_universidad = []
    usuarios_a_borrar = []

    if tipoBorrado == "Universidad":
        universidad = Universidad.objects.filter( id = identificador )
    elif tipoBorrado == "Region":
        universidad = Universidad.objects.filter( region_id = identificador )
        region = Region.objects.get(id = identificador)

    for universidad_aux in universidad:
        usuarios = Usuario.objects.filter( universidad = universidad_aux.id )
        for usuarios_aux in usuarios:
            user = User.objects.get( id = usuarios_aux.user_id )
            if user.groups.filter( name = 'Adm. Regional' ).exists(): #si el usuario es admin de alguna region
                if tipoBorrado == "Region":
                    if not(int(usuarios_aux.user_id) == int(region.administrador_id)): #si es admin de una region diferente a la que se quiere borrar
                        mensaje_usuarios_regional.append(user.username)
                    #else:
                    #    g = Group.objects.get( name = 'Adm. Regional' ) #si es el admin de la region a borrar, se le quita este atributo
                    #    g.user_set.remove( user )
                else:
                    mensaje_usuarios_regional.append(user.username) #es admin de alguna region
            
            if user.groups.filter( name = 'Adm. Institucional' ).exists(): #si el usuario es admin de alguna otra universidad
                if not(int(usuarios_aux.universidad_id) == int(universidad_aux.id)): #si esta asociado a una universidad diferente a la actual. Si solo es la actual, se puede borrar tranquilamente.
                    mensaje_usuarios_institucional.append(user.username)
                #else:
                #    g = Group.objects.get( name = 'Adm. Institucional' )
                #    g.user_set.remove( user )

            usuarios_a_borrar.append(usuarios_aux)


        #guardamos los datos por universidad
        mensaje_universidad.append((universidad_aux.nombre, mensaje_usuarios_institucional, mensaje_usuarios_regional))
        mensaje_usuarios_regional = []
        mensaje_usuarios_institucional = []


    mtx = {
            'mensaje_universidad':mensaje_universidad,
            'usuarios_a_borrar':usuarios_a_borrar 
            }

    return mtx

def admin_universidades( request, identificador = -1 ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''

        if 'message' in request.GET:
            message = request.GET['message'].split( '/' )[0]
            tipo = request.GET['message'].split( '/' )[1]
            if tipo == "exito":
                show_message_success = True
                mensaje_exito += message
            elif tipo == "error":
                show_message_error = True
                mensaje_error += message


        # # Se elimina la universidad, junto con los usuarios asociados a ella. Se envia un correo al usuario respectivo, informandole de la baja.
        # if ( identificador != -1 ):

        #     if Universidad.objects.filter( id = identificador ).exists():
        #         uni = Universidad.objects.get( id = identificador )
        #         #envioMailAlBorrarUniversidad( identificador )
        #         try:
        #             uni.delete()
        #             show_message_success = True
        #             show_message_error = False
        #             mensaje_exito += "<p><strong>El borrado ha sido exitoso!!</strong>"
        #         except Exception, e:
        #             show_message_error = True
        #             show_message_success = False
        #             mensaje_error += "<strong>Error!</strong>Ha ocurrido un problema con el borrado. Intente de nuevo.<strong>Captura del error:</strong><p>" + str( e )
        #     else:
        #         show_message_success = True
        #         show_message_error = False
        #         mensaje_exito += "<p><strong>El borrado ha sido exitoso!!</strong>"

        menu = sidebar( request )
        universidades = Universidad.objects.all()
        regiones = Region.objects.all()
        mtx = {'universidades':universidades,
                'regiones':regiones,
                'menu' : menu,
                'show_message_success': show_message_success,
                'show_message_error': show_message_error,
                'mensaje_error':mensaje_error,
                'mensaje_exito':mensaje_exito}
        mtx = desplegar_indicadores_universidad( mtx )
        context_instance = RequestContext( request )
        return render_to_response( 'admin_universidades.html', mtx, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def agregar_universidades( request ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''

        if request.method == 'POST':
            administrador = request.POST['administrador']
            nombre = unicode( request.POST['name'] )
            telefono = ''
            url = unicode( request.POST['URL'] )
            # parseamos la url para obtener solo la parte del www...
            url_aux = url.split( '//' )
            if len( url_aux ) == 1:  # la url ingresada es del tipo www... entonces se le pasa ese valor del vector en [0]
                url = url_aux[0]
            elif len( url_aux ) == 2:  # la url ingresada es del tipo http://www... o https://www..., por eso le pasamos el segundo valor del vector ([1]) al hacer el split, que seria la parte del wwww..
                url = url_aux[1]

            pais = request.POST['paises']
            direccion = ''
            siglas = ''
            if 'sigla' in request.POST:
                siglas = unicode( request.POST['sigla'] )

            if 'Direccion' in request.POST:
                direccion = unicode( request.POST['Direccion'] )

            if 'telefono' in request.POST:
                telefono = unicode( request.POST['telefono'] )

            if 'cod_pais' in request.POST:
                cod_pais = unicode( request.POST['cod_pais'] )

            if 'cod_ciudad' in request.POST:
                cod_ciudad = unicode( request.POST['cod_ciudad'] )

            ##############################Validaciones del formulario################
             # ##Verificamos que los campos Required, no vengan vacios
            if nombre == '':
                mensaje_error += "<p>El campo nombre no debe estar vacío."

            if url == '':
                mensaje_error += "<p>El campo URL no debe estar vacío."
            elif ( Universidad.objects.filter( url = unicode( url ) ).exists() ):  # se verifica que la url ingresada no esté duplicada
                mensaje_error += "La URL ingresada ya existe. Ingrese uno diferente."
            elif not( re.match( r"^((http:\/\/www\.|https:\/\/www\.|www\.)[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*\.[a-zA-Z]{2,6}(?:\/?|(?:\/[\w\-]+)*)(?:\/?|\/\w+\.[a-zA-Z]{2,4}(?:\?[\w]+\=[\w\-]+)?)?(?:\&[\w]+\=[\w\-]+)*)$", url ) ):
                mensaje_error += "Verifique el formato de la url."

            if mensaje_error != '':  # si hubo algun error, volvemos a la pagina agregar_universidad, para corregir dichos errores
                show_message_error = True
                pais_region = Pais_region.objects.all()
                universidades = Universidad.objects.all()
                users = User.objects.all();
                usuarios = []
                admin_id = []

                for user_temp in users:
                    usuarios.append( user_temp )
                    admin_id.append( user_temp.id )

                for universidad_temp in universidades:
                    temp = User.objects.get( id = universidad_temp.administrador_id )
                    usuarios.remove( temp )
                    admin_id.remove( universidad_temp.administrador_id )

                usuarios_sinc = zip( admin_id, usuarios )

                lista_sinc_paises = listarPaises( modelo = "Pais_region" )
                menu = sidebar( request )
                mtx = {
                    'usuarios': usuarios_sinc,
                    'lista_sinc_paises': lista_sinc_paises,
                    'menu' : menu,
                    'show_message_success': show_message_success,
                    'show_message_error': show_message_error,
                    'mensaje_error':mensaje_error,
                    'mensaje_exito':mensaje_exito
                }
                return render_to_response( 'agregar_universidades.html', mtx, context_instance = RequestContext( request ) )
            ###############################Fin de las validaciones###################

            telefono = cod_pais + "-" + cod_ciudad + "-" + telefono  # reconstruimos el telefono

            region = Pais_region.objects.get( pais = pais )
            region_id = region.region_id

            respuesta = Universidad( nombre = nombre, administrador_id = administrador, region_id = region_id, siglas = siglas, telefono = telefono, url = url, pais = pais, direccion = direccion )
            try:
                respuesta.save()
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            #********al administrador de la universidad lo agregamos a userGroup como adm. institucional
            g = Group.objects.get( name = 'Adm. Institucional' )
            g.user_set.add( administrador )

            #**************modificar la tabla usuario_usuario*******************
            user = User.objects.get( id = administrador )
            universidad_aux = Universidad.objects.get( url = url )
            # eliminamos el registro actual del usuario en la tabla usuario+_usuario
            Usuario.objects.filter( user = user ).delete()
            # agregamos al usuario (user con su universidad). NUEVA ASOCIACION
            usuario = Usuario( user = user, universidad = universidad_aux )
            usuario.save()

            return redirect( '/plataforma/universidades/admin_universidades/' + "?message=La universidad ha sido creada con exito./exito" )


        pais_region = Pais_region.objects.all()
        universidades = Universidad.objects.all()
        users = User.objects.all();
        usuarios = []
        admin_id = []

        for user_temp in users:
            usuarios.append( user_temp )
            admin_id.append( user_temp.id )

        for universidad_temp in universidades:
            temp = User.objects.get( id = universidad_temp.administrador_id )
            usuarios.remove( temp )
            admin_id.remove( universidad_temp.administrador_id )

        usuarios_sinc = zip( admin_id, usuarios )

        lista_sinc_paises = listarPaises( modelo = "Pais_region" )
        menu = sidebar( request )
        mtx = {
            'usuarios': usuarios_sinc,
            'lista_sinc_paises': lista_sinc_paises,
            'menu' : menu,
            'show_message_success': show_message_success,
            'show_message_error': show_message_error,
            'mensaje_error':mensaje_error,
            'mensaje_exito':mensaje_exito
        }
        return render_to_response( 'agregar_universidades.html', mtx, context_instance = RequestContext( request ) )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def edicion_universidades( request, identificador, administrador, region ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''
        if request.method == 'POST':
            identificador_univ = request.POST['id']
            administrador = request.POST['administrador']
            nombre = unicode( request.POST['name'] )
            telefono = ''
            url = unicode( request.POST['URL'] )
            # parseamos la url para obtener solo la parte del www...
            url_aux = url.split( '//' )
            if len( url_aux ) == 1:  # la url ingresada es del tipo www... entonces se le pasa ese valor del vector en [0]
                url = url_aux[0]
            elif len( url_aux ) == 2:  # la url ingresada es del tipo http://www... o https://www..., por eso le pasamos el segundo valor del vector ([1]) al hacer el split, que seria la parte del wwww..
                url = url_aux[1]

            url_antesEdicion = unicode( request.POST['url'] )
            pais = request.POST['paises']
            direccion = ''
            siglas = ''
            if 'sigla' in request.POST:
                siglas = unicode( request.POST['sigla'] )

            if 'Direccion' in request.POST:
                direccion = unicode( request.POST['Direccion'] )

            if 'telefono' in request.POST:
                telefono = unicode( request.POST['telefono'] )

            if 'cod_pais' in request.POST:
                cod_pais = unicode( request.POST['cod_pais'] )

            if 'cod_ciudad' in request.POST:
                cod_ciudad = unicode( request.POST['cod_ciudad'] )

            ########################Validaciones del formulario############################
            if nombre == '':
                mensaje_error += "<p>El campo nombre no debe estar vacío."

            if url == '':
                mensaje_error += "<p>El campo URL no debe estar vacío."
            elif ( Universidad.objects.filter( url = unicode( url ) ).exists() and url != url_antesEdicion ):  # se verifica que la url ingresada no esté duplicada
                mensaje_error += "La URL ingresada ya existe. Ingrese uno diferente."
            elif not( re.match( r"^((http:\/\/www\.|https:\/\/www\.|www\.)[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*\.[a-zA-Z]{2,6}(?:\/?|(?:\/[\w\-]+)*)(?:\/?|\/\w+\.[a-zA-Z]{2,4}(?:\?[\w]+\=[\w\-]+)?)?(?:\&[\w]+\=[\w\-]+)*)$", url ) ):
                mensaje_error += "Verifique el formato de la url."

            if mensaje_error != '':  # si hubo algun error, volvemos a la pagina Edicion_universidad, para corregir dichos errores
                show_message_error = True
                universidades = Universidad.objects.all()
                universidades_nombre = Universidad.objects.get( id = identificador )
                administrador_nombre = User.objects.get( id = administrador )
                users = User.objects.all()

                universidades = Universidad.objects.all()
                usuarios = []
                admin_id = []

                for user_temp in users:
                    usuarios.append( user_temp )
                    admin_id.append( user_temp.id )

                for universidad_temp in universidades:
                    temp = User.objects.get( id = universidad_temp.administrador_id )

                    if unicode( universidad_temp.nombre ) != unicode( universidades_nombre.nombre ):
                        usuarios.remove( temp )
                        admin_id.remove( universidad_temp.administrador_id )

                usuarios_sinc = zip( admin_id, usuarios )

                menu = sidebar( request )
                lista_sinc_paises = listarPaises( modelo = "Pais_region" )
                telefono = ( universidades_nombre.telefono ).split( '-' )  # parsear telefono en cod_pais,cod_ciudad, telefono
                mtx = {'universidades': universidades,
                        'iduniversidad' : int( identificador ),
                        'universidades_nombre' : universidades_nombre.nombre,
                        'cod_pais' : telefono[0],
                        'cod_ciudad' : telefono[1],
                        'telefono' : telefono[2],
                        'url' : universidades_nombre.url,
                        'pais' : universidades_nombre.pais,
                        'siglas' : universidades_nombre.siglas,
                        'direccion' : universidades_nombre.direccion,
                        'idadministrador': universidades_nombre.administrador_id,
                        'lista_sinc_paises': lista_sinc_paises,
                        'usuarios': usuarios_sinc,
                        'region_id' : universidades_nombre.region_id,
                        'menu' : menu,
                        'show_message_success': show_message_success,
                        'show_message_error': show_message_error,
                        'mensaje_error':mensaje_error,
                        'mensaje_exito':mensaje_exito
                    }
                context_instance = RequestContext( request )
                return render_to_response( 'edicion_universidades.html', mtx, context_instance = context_instance )
            ########################FIN DE LAS VERIFICACIONES##############################
            telefono_completo = cod_pais + "-" + cod_ciudad + "-" + telefono  # reconstruimos el telefono

            #**vemos quien es el actual adm de la universidad
            administradorActual = Universidad.objects.get(id = identificador_univ)
            userAdmin = User.objects.get(id = administradorActual.administrador_id)

            #*****Remover el actual administrador institucional de la univ de la tabla UserGroup
            if userAdmin.groups.filter( name = 'Adm. Institucional' ).exists():
                g = Group.objects.get( name = 'Adm. Institucional' )
                g.user_set.remove( administradorActual.administrador_id )


            region = Pais_region.objects.get( pais = pais )
            region_id = region.region_id
            universidad = Universidad.objects.get( id = identificador_univ )
            universidad.nombre = nombre
            universidad.administrador_id = administrador
            universidad.region_id = region_id
            universidad.telefono = telefono_completo
            universidad.url = url
            universidad.pais = pais
            universidad.siglas = siglas
            universidad.direccion = direccion
            try:
                universidad.save()
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            #*******ponemos al administrador nuevo en el grupo como Adm. Institucional
            g = Group.objects.get( name = 'Adm. Institucional' )
            g.user_set.add( administrador )
            

            #**************modificar la tabla usuario_usuario*******************
            user = User.objects.get( id = administrador )
            universidad_aux = Universidad.objects.get( id = identificador_univ )
            # eliminamos el registro actual del usuario en la tabla usuario_usuario
            Usuario.objects.filter( user = user ).delete()
            # agregamos al usuario (user con su universidad). NUEVA ASOCIACION
            usuario = Usuario( user = user, universidad = universidad_aux )
            usuario.save()

            return redirect( '/plataforma/universidades/admin_universidades/' + "?message=La universidad ha sido editada con exito./exito" )


        universidades = Universidad.objects.all()
        universidades_nombre = Universidad.objects.get( id = identificador )
        administrador_nombre = User.objects.get( id = administrador )
        users = User.objects.all()

        universidades = Universidad.objects.all()
        usuarios = []
        admin_id = []

        for user_temp in users:
            usuarios.append( user_temp )
            admin_id.append( user_temp.id )

        for universidad_temp in universidades:
            temp = User.objects.get( id = universidad_temp.administrador_id )
            if unicode( universidad_temp.nombre ) != unicode( universidades_nombre.nombre ):
                usuarios.remove( temp )
                admin_id.remove( universidad_temp.administrador_id )

        usuarios_sinc = zip( admin_id, usuarios )

        menu = sidebar( request )
        lista_sinc_paises = listarPaises( modelo = "Pais_region" )
        telefono = ( universidades_nombre.telefono ).split( '-' )  # parsear telefono en cod_pais,cod_ciudad, telefono
        mtx = {'universidades': universidades,
                'iduniversidad' : int( identificador ),
                'universidades_nombre' : universidades_nombre.nombre,
                'cod_pais' : telefono[0],
                'cod_ciudad' : telefono[1],
                'telefono' : telefono[2],
                'url' : universidades_nombre.url,
                'pais' : universidades_nombre.pais,
                'siglas' : universidades_nombre.siglas,
                'direccion' : universidades_nombre.direccion,
                'idadministrador': universidades_nombre.administrador_id,
                'lista_sinc_paises': lista_sinc_paises,
                'usuarios': usuarios_sinc,
                'region_id' : universidades_nombre.region_id,
                'menu' : menu,
                'show_message_success': show_message_success,
                'show_message_error': show_message_error,
                'mensaje_error':mensaje_error,
                'mensaje_exito':mensaje_exito
                }
        context_instance = RequestContext( request )
        return render_to_response( 'edicion_universidades.html', mtx, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def desplegar_indicadores_universidad( mx ):
    lista = '<table border = "0"  width="100%" class="table table-striped">'
    contador = 0
    if len(mx['universidades']) == 0:
        lista = lista + '<tr><td><i>No existen universidades en el sistema.</i></td></tr>'
    else:    
        for region in mx['regiones']:
            lista = lista + '<tr><th  colspan="4"><b>>> ' + unicode( region.nombre ) + '</b></th></tr>'
            for univ in mx['universidades']:
                if region.id == univ.region_id:
                    contador = contador + 1
                    lista = lista + '<tr><td  width="40%" align = "center">' + unicode( univ.nombre ) + '</td>'
                    lista = lista + '<td width="5%" align = "center"><a class="btn btn-primary" onClick="javascript:verDatos(' + unicode( univ.id ) + ')">Ver &raquo</a></td><td width="5%" align = "center"><a class="btn btn-primary" href="/plataforma/universidades/edicion_universidades/' + unicode( univ.id ) + '/' + unicode( univ.administrador_id ) + '/' + unicode( univ.region_id ) + '">Editar &raquo</a></td>'
                    lista = lista + '<td width="5%" align = "center"><a class="btn btn-primary" onClick="javascript:eliminar(' + unicode( univ.id ) + ')">Eliminar &raquo</a></td></tr>'

            if contador == 0:
                lista = lista + '<tr><td align = "center"><i><h5>No hay universidades asociadas.</h5></i></td></tr>'
            
            contador = 0
    
    lista = lista + '</table>'
    mx.update( {'lista':lista} )
    return mx
#***********************************************************Region**************************************************************************
def admin_region( request, identificador = -1 ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''

        if 'message' in request.GET:
            print "Estoy dentro!!! del GET region"
            message = request.GET['message'].split( '/' )[0]
            tipo = request.GET['message'].split( '/' )[1]
            if tipo == "exito":
                show_message_success = True
                mensaje_exito += message
            elif tipo == "error":
                show_message_error = True
                mensaje_error += message
            elif tipo == "":
                show_message_error = False
                show_message_success = False

        # if int( identificador ) != -1:
        #     try:
        #         pais = Pais_region.objects.get(region_id = identificador)
        #         region = Region.objects.get( id = identificador )
        #         u = User.objects.get(id = region.administrador_id)
        #         if u.groups.filter( name = 'Adm. Regional' ).exists():
        #             asunto = 'Baja como administrador regional de la plataforma '
        #             mensaje = 'Su usuario ha sido dado de baja como administrador regional, de la plataforma Vincula Entorno, debido a que a la región a la que se encontraba asociada ha sido removida del mismo.\n\nEquipo Vincula Entorno.'
        #             recipients = [unicode( u.email )]
        #             #correo = EmailMessage( asunto, mensaje, 'evincula@gmail.com', recipients, [], headers = {} )
                    
        #             try:
        #                 #correo.send()
        #                 send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)

        #             except Exception, e:
        #                 print e
        #             g = Group.objects.get( name = 'Adm. Regional' )
        #             g.user_set.remove( u )

        #         # if Universidad.objects.filter( pais = pais.pais ).exists():  # borrado de las universidades asociadas al pais. A cada una de las universidades se les envia un mail.
        #         #     universidad = Universidad.objects.filter( pais = pais.pais ) 
        #         #     for universidad_temp in universidad:
        #         #         envioMailAlBorrarUniversidad( universidad_temp.id )
        #         #         universidad_temp.delete()
        #         Region.objects.filter( id = identificador ).delete()
        #         show_message_success = True
        #         show_message_error = False
        #         mensaje_exito += "<p><strong>El borrado ha sido exitoso!!</strong>"
        #     except Exception, e:
        #         show_message_error = True
        #         show_message_success = False
        #         mensaje_error += "<strong>Error!</strong>Ha ocurrido un problema con el borrado. Intente de nuevo.<p><strong>Captura del error:</strong><p>" + str( e )



        regiones = Region.objects.all()
        menu = sidebar( request )
        context = Context( {
            'regiones' : regiones,
            'menu' : menu,
            'show_message_success': show_message_success,
            'show_message_error': show_message_error,
            'mensaje_error':mensaje_error,
            'mensaje_exito':mensaje_exito
        } )
        context = desplegar_indicadores_region( context )
        context_instance = RequestContext( request )
        return render_to_response( 'admin_region.html', context, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def agregar_region( request ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''
        if request.method == 'POST':
            pais = request.POST['pais']
            administrador_region = request.POST['administrador']
            nombre = unicode( request.POST['name'] )

            ###############Validaciones del formulario################
            if nombre == '':
                mensaje_error += "<p>El campo nombre de la región no debe estar vacío."

            if pais == '':
                mensaje_error += "<p> Debe seleccionar un pais para asociarlo a una región."
            
            if administrador_region == '':
                mensaje_error += "<p>Debe seleccionar un administrador para la región."

            if mensaje_error != '':
                show_message_error = True
                users = User.objects.all()
                regiones = Region.objects.all()
                paisesEnLista = Pais_region.objects.filter()
                usuarios = []
                admin_id = []

                lista_de_paises = []
                nombre_de_paises = []

                #lista de usuarios disponibles para ser administradores, no repetidos
                for user_temp in users:
                    usuarios.append( user_temp )
                    admin_id.append( user_temp.id )

                for regiones_temp in regiones:
                    temp = User.objects.get( id = regiones_temp.administrador_id )
                    usuarios.remove( temp )
                    admin_id.remove( regiones_temp.administrador_id )

                #lista de paises-regiones disponibles, no repetidos
                for codigo, nombre in COUNTRIES:
                    if len(paisesEnLista): #la primera vez, pais_region esta vacio. Preguntamos si el vector esta vacio
                        for paisesTemp in paisesEnLista:
                            if codigo != paisesTemp.pais:# se quita las regiones ya cargadas
                                lista_de_paises.append(codigo)
                                nombre_de_paises.append(nombre)
                    else:
                        lista_de_paises.append(codigo)
                        nombre_de_paises.append(nombre)

                lista_de_paises = unicos_manteniendo_orden( lista_de_paises )
                nombre_de_paises = unicos_manteniendo_orden( nombre_de_paises )


                lista_sinc_paises = zip( lista_de_paises, nombre_de_paises )
                usuarios_sinc = zip( admin_id, usuarios )
                users = User.objects.all()
                menu = sidebar( request )
                mtx = { 'usuarios': usuarios_sinc,
                        'lista_sinc_paises': lista_sinc_paises,
                        'menu' : menu,
                        'show_message_success': show_message_success,
                        'show_message_error': show_message_error,
                        'mensaje_error':mensaje_error,
                        'mensaje_exito':mensaje_exito
                      }
                return render_to_response( 'agregar_region.html', mtx, context_instance = RequestContext( request ) )
            ###################FIN DE LAS VALIDACIONES################

            #guardamos la region
            respuesta = Region( nombre = nombre, administrador_id = administrador_region )
            try:
                respuesta.save()
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            region = Region.objects.get(nombre = nombre) #Region recien guardada
            #guardamos el pais con su region
            respuesta = Pais_region( pais = pais, region_id = region.id )
            try:
                respuesta.save()  # guardar
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )
            

            #****Ponemos al administrador nuevo en el grupo como Adm. Regional
            g = Group.objects.get( name = 'Adm. Regional' )
            g.user_set.add( administrador_region )

            return redirect( '/plataforma/universidades/admin_region/' + "?message=La region ha sido creada con exito./exito" )
        # endif

        users = User.objects.all()
        regiones = Region.objects.all()
        paisesEnLista = Pais_region.objects.filter()
        usuarios = []
        admin_id = []

        lista_de_paises = []
        nombre_de_paises = []

        #lista de usuarios disponibles para ser administradores, no repetidos
        for user_temp in users:
            usuarios.append( user_temp )
            admin_id.append( user_temp.id )

        for regiones_temp in regiones:
            temp = User.objects.get( id = regiones_temp.administrador_id )
            usuarios.remove( temp )
            admin_id.remove( regiones_temp.administrador_id )

        #lista de paises-regiones disponibles, no repetidos
        for codigo, nombre in COUNTRIES:
            if len(paisesEnLista): #la primera vez, pais_region esta vacio. Preguntamos si el vector esta vacio
                for paisesTemp in paisesEnLista:
                    if codigo != paisesTemp.pais:# se quita las regiones ya cargadas
                        lista_de_paises.append(codigo)
                        nombre_de_paises.append(nombre)
            else:
                lista_de_paises.append(codigo)
                nombre_de_paises.append(nombre)

        lista_de_paises = unicos_manteniendo_orden( lista_de_paises )
        nombre_de_paises = unicos_manteniendo_orden( nombre_de_paises )


        lista_sinc_paises = zip( lista_de_paises, nombre_de_paises )
        usuarios_sinc = zip( admin_id, usuarios )
        users = User.objects.all()
        menu = sidebar( request )
        mtx = { 'usuarios': usuarios_sinc,
                'lista_sinc_paises': lista_sinc_paises,
                'menu' : menu,
                'show_message_success': show_message_success,
                'show_message_error': show_message_error,
                'mensaje_error':mensaje_error,
                'mensaje_exito':mensaje_exito
              }
        return render_to_response( 'agregar_region.html', mtx, context_instance = RequestContext( request ) )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )


def edicion_region( request, identificador, administrador ):
    if request.user.is_staff:
        show_message_success = False
        show_message_error = False
        mensaje_error = ''
        mensaje_exito = ''
        if request.method == 'POST':
            pais = request.POST['pais']
            identificador_region = request.POST['id']
            administrador_region = request.POST['administrador']
            nombre = unicode( request.POST['name'] )
            ###############Validaciones del formulario################
            if nombre == '':
                mensaje_error += "<p>El campo nombre de la región no debe estar vacío."

            if pais == '':
                mensaje_error += "<p> Debe seleccionar un pais para asociarlo a una región."

            if administrador_region == '':
                mensaje_error += "<p>Debe seleccionar un administrador para la región."

            if mensaje_error != '':
                show_message_error = True
                users = User.objects.all()
                regiones = Region.objects.all()
                region_nombre = Region.objects.get( id = identificador )
                pais = Pais_region.objects.get(region_id = identificador)
                paisesEnLista = Pais_region.objects.filter()
                user_name = User.objects.get( id = region_nombre.administrador_id )
                usuarios = []
                admin_id = []

                lista_de_paises = []
                nombre_de_paises = []
                
                #lista de paises-regiones disponibles, no repetidos
                for codigo, nombre in COUNTRIES:
                    if len(paisesEnLista): #la primera vez, pais_region esta vacio. Preguntamos si el vector esta vacio
                        for paisesTemp in paisesEnLista:
                            if codigo != paisesTemp.pais:# se quita las regiones ya cargadas
                                lista_de_paises.append(codigo)
                                nombre_de_paises.append(nombre)
                    else:
                        lista_de_paises.append(codigo)
                        nombre_de_paises.append(nombre)

                lista_de_paises = unicos_manteniendo_orden( lista_de_paises )
                nombre_de_paises = unicos_manteniendo_orden( nombre_de_paises )

                lista_sinc_paises = zip( lista_de_paises, nombre_de_paises )

                #lista de usuarios disponibles para ser administradores, no repetidos
                for user_temp in users:
                    usuarios.append( user_temp )
                    admin_id.append( user_temp.id )

                for regiones_temp in regiones:
                    temp = User.objects.get( id = regiones_temp.administrador_id )

                    if unicode( temp.username ) != unicode( user_name.username ):
                        usuarios.remove( temp )
                        admin_id.remove( regiones_temp.administrador_id )

                usuarios_sinc = zip( admin_id, usuarios )

                administrador_nombre = User.objects.get( id = administrador )

                users = User.objects.all()
                menu = sidebar( request )
                mtx = {'regiones': regiones,
                        'lista_sinc_paises': lista_sinc_paises,
                        'pais_selected_codigo': pais.pais,
                        'usuarios':usuarios_sinc,
                        'identificador' : identificador,
                        'region_nombre' : region_nombre,
                        'idadministrador': int( administrador ),
                        'administrador_nombre' : administrador_nombre,
                        'users' : users,
                        'menu' : menu,
                        'show_message_success': show_message_success,
                        'show_message_error': show_message_error,
                        'mensaje_error':mensaje_error,
                        'mensaje_exito':mensaje_exito
                    }
                context_instance = RequestContext( request )
                return render_to_response( 'edicion_region.html', mtx, context_instance = context_instance )
            ###################FIN DE LAS VALIDACIONES################
            
            #***Vemos quien es el actual adm de la region
            regionActual = Region.objects.get(id = identificador_region)
            regionAdmin = User.objects.get(id = regionActual.administrador_id)

            #***Remover el actual administrador regional de la region de la tabla UserGroup
            if regionAdmin.groups.filter( name = 'Adm. Regional' ).exists():
                g = Group.objects.get( name = 'Adm. Regional' )
                g.user_set.remove(regionActual.administrador_id)
            
            #***Guardamos la region
            respuesta = Region( id = identificador_region, nombre = nombre, administrador_id = administrador_region )
            try:
                respuesta.save()
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            #***Actualizar el pais y region de la tabla universidad
            if(Universidad.objects.filter( region_id = identificador_region ).exists()):
                universidad = Universidad.objects.filter( region_id = identificador_region )  
                for uni in universidad:#actualizamos todos los registros con dicho pais
                    uni.pais = pais
                    try:
                        uni.save()
                    except Exception, e:
                        return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            #***Actualizar tabla Pais-Region
            pais_region = Pais_region.objects.get( region_id = identificador_region )
            pais_region.pais = pais
            try:
                pais_region.save()
            except Exception, e:
                return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

            #****Ponemos al administrador nuevo en el grupo como Adm. Regional
            g = Group.objects.get( name = 'Adm. Regional' )
            g.user_set.add( administrador_region )

            return redirect( '/plataforma/universidades/admin_region/' + "?message=La region ha sido editada con exito./exito" )



        users = User.objects.all()
        regiones = Region.objects.all()
        region_nombre = Region.objects.get( id = identificador )
        pais = Pais_region.objects.get(region_id = identificador)
        paisesEnLista = Pais_region.objects.filter()
        user_name = User.objects.get( id = region_nombre.administrador_id )
        usuarios = []
        admin_id = []

        lista_de_paises = []
        nombre_de_paises = []
        
        #lista de paises-regiones disponibles, no repetidos
        for codigo, nombre in COUNTRIES:
            if len(paisesEnLista): #la primera vez, pais_region esta vacio. Preguntamos si el vector esta vacio
                for paisesTemp in paisesEnLista:
                    if codigo != paisesTemp.pais:# se quita las regiones ya cargadas
                        lista_de_paises.append(codigo)
                        nombre_de_paises.append(nombre)
            else:
                lista_de_paises.append(codigo)
                nombre_de_paises.append(nombre)

        lista_de_paises = unicos_manteniendo_orden( lista_de_paises )
        nombre_de_paises = unicos_manteniendo_orden( nombre_de_paises )

        lista_sinc_paises = zip( lista_de_paises, nombre_de_paises )

        #lista de usuarios disponibles para ser administradores, no repetidos
        for user_temp in users:
            usuarios.append( user_temp )
            admin_id.append( user_temp.id )

        for regiones_temp in regiones:
            temp = User.objects.get( id = regiones_temp.administrador_id )

            if unicode( temp.username ) != unicode( user_name.username ):
                usuarios.remove( temp )
                admin_id.remove( regiones_temp.administrador_id )

        usuarios_sinc = zip( admin_id, usuarios )

        administrador_nombre = User.objects.get( id = administrador )

        users = User.objects.all()
        menu = sidebar( request )
        mtx = {'regiones': regiones,
                'lista_sinc_paises': lista_sinc_paises,
                'pais_selected_codigo': pais.pais,
                'usuarios':usuarios_sinc,
                'identificador' : identificador,
                'region_nombre' : region_nombre,
                'idadministrador': int( administrador ),
                'administrador_nombre' : administrador_nombre,
                'users' : users,
                'menu' : menu,
                'show_message_success': show_message_success,
                'show_message_error': show_message_error,
                'mensaje_error':mensaje_error,
                'mensaje_exito':mensaje_exito
            }
        context_instance = RequestContext( request )
        return render_to_response( 'edicion_region.html', mtx, context_instance = context_instance )
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def desplegar_indicadores_region( mx ):
    lista = u'<table border = "0" width="100%" class="table table-striped"><tr><th width = "50%">Nombre de la Región</th><th width = "50%" colspan="3">Opciones</th></tr>'
    if len(mx['regiones']) == 0:
        lista = lista + '<tr><td><i>No existen regiones en el sistema.</i></td></tr>'
    else:
        for region in mx['regiones']:
            lista = lista + '<tr><td width = "20%" align = "center">' + unicode( region.nombre ) + '</td><td width = "5%" align = "center"><a class="btn btn-primary" onClick="javascript:verDatos(' + unicode( region.id ) + ')">Ver &raquo</a></td>'
            lista = lista + '<td width = "5%" align = "center"><a class="btn btn-primary" href="/plataforma/universidades/edicion_region/' + unicode( region.id ) + '/' + unicode( region.administrador_id ) + '">Editar &raquo</a></td>'
            lista = lista + '<td width = "5%" align = "center"><a class="btn btn-primary" onClick="javascript:eliminar(' + unicode( region.id ) + ')">Eliminar &raquo</a></td></tr>'

    lista = lista + '</table>'
    mx.update( {'lista':lista} )
    return mx

def listarPaises( modelo ):
    if modelo == "Pais_region":
        modelo = Pais_region.objects.all()
    elif modelo == "Universidad":
         modelo = Universidad.objects.all()

    lista_de_paises = []
    nombre_de_paises = []
    for model in modelo:
        lista_de_paises.append( model.pais )
        nombre_de_paises.append( model.pais.name )

    lista_de_paises = unicos_manteniendo_orden( lista_de_paises )
    nombre_de_paises = unicos_manteniendo_orden( nombre_de_paises )

    lista_sinc_paises = zip( lista_de_paises, nombre_de_paises )
    return lista_sinc_paises

def agregarUniv( request ):
    regiones = Region.objects.all()
    universidades = Universidad.objects.all()
    lista_sinc_paises = listarPaises( modelo = "Pais_region" )

    if request.method == 'POST':
        regionAux = Pais_region.objects.get( pais = request.POST['pais'] )
        # se concatenan todos los campos que comprenden el telefono en una nueva variable; cod de pais, cod de area y el numero de telefono
        postTelefono = unicode( request.POST['cod_pais'] ) + '-' + unicode( request.POST['cod_ciudad'] ) + '-' + unicode( request.POST['telefono'] )
        postuniv = request.POST.copy()  # se define una variable para copiar los datos extraidos con el POST
        postuniv.update( {'region' : regionAux.region_id } )
        postuniv.update( {'nombre' : postuniv['nombreUniv']} )  # se redefine el nombre que posee el field en el POST
        postuniv.update( {'telefono' : postTelefono} )  # se reemplaza el campo telefono por el nuevo numero con todos los codigos incluidos
        formUser = RegistroUserForm( request.POST )  # se crea una variable con los campos extraidos del POST y cargados al Form del user

        if formUser.is_valid():
            formUser.save()  # si todo esta correcto, se guardan los datos del user

            # se recuperan todos los datos que se guardaron recien con el formUser
            user = User.objects.get( username = unicode( request.POST['email'] ) )

            # se actualiza la variable administrador con el id del user recuperado
            postuniv.update( {'administrador' : user.id} )
            formUniv = RegistroUnivForm( postuniv )  # se crea la variable para la universidad con los datos solicitados previamente del POST

            if formUniv.is_valid():
                formUniv.save()  # si todo esta correcto, se guardan los datos de la universidad

                context = Context( {
                'login_error': False,
                'registro_error': False,
                'registro_check': True,
                'regiones' : regiones,
                'universidades': universidades,
                'lista_sinc_paises': lista_sinc_paises,
                } )

                asunto = 'Solicitud de ingreso de Universidad'
                mensaje = u'Se ha solicitado la Inscripción de una nueva Universidad. ' + unicode( request.POST['nombreUniv'] ) + ', por ' + unicode( request.POST['email'] ) + '.'
                recipients2 = []
                recipients = ['evincula@gmail.com']

                # Arma el correo con los datos, recipents puede ser modificado para poner el correo del encargado de responder consultas, con el header reply to facilita la respuesta a correos
                correo = EmailMessage( asunto, mensaje, 'evincula@gmail.com', recipients2, recipients, headers = {} )

                context_instance = RequestContext( request )
                return render_to_response( 'registrouniv.html', context,
                                  context_instance = context_instance )

            else:
                user.delete()
                context = Context( {
                'login_error': False,
                'registro_error': True,
                'registro_check': False,
                'universidades': universidades,
                'regiones' : regiones,
                'lista_sinc_paises': lista_sinc_paises,
                } )

                context_instance = RequestContext( request )
                return render_to_response( 'registrouniv.html', context,
                                  context_instance = context_instance )
        else:
            context = Context( {
                'login_error': False,
                'registro_error': True,
                'registro_check': False,
                'universidades': universidades,
                'regiones' : regiones,
                'lista_sinc_paises': lista_sinc_paises,
            } )

            context_instance = RequestContext( request )
            return render_to_response( 'registrouniv.html', context,
                              context_instance = context_instance )

    return render( request, 'index.html' )

def registro( request ):
    url = request.get_full_path()
    universidades = Universidad.objects.all()
    regiones = Region.objects.all()


    if request.user.is_authenticated():
        return redirect( '/plataforma/home' )

    is_adm_institucional = request.user.groups.filter( 
        name = 'Adm. Institucional' ).exists()
    is_adm_regional = request.user.groups.filter( 
        name = 'Adm. Regional' ).exists()

    lista_sinc_paises = listarPaises( modelo = "Pais_region" )

    context = Context( {
        'url': url,
        'universidades': universidades,
        'regiones' : regiones,
        'lista_sinc_paises': lista_sinc_paises,
        'is_adm_institucional':is_adm_institucional,
        'is_adm_regional': is_adm_regional,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'registrouniv.html', context,
                              context_instance = context_instance )

@csrf_exempt
def validar( request, fila = 0 ):  #########################################################################################################################
    url = request.get_full_path()
    universidades = Universidad.objects.all()
    regiones = Region.objects.all()
    user = User.objects.all()

    is_adm_regional = request.user.groups.filter( name = 'Adm. Regional' ).exists()

    if not is_adm_regional:
        return HttpResponse( respuestahttp() )

    menu = sidebar( request )
    context = Context( {
        'url': url,
        'universidades': universidades,
        'regiones' : regiones,
        'menu': menu,
    } )

    info = "Iniciado"
    if request.method == 'POST':

        if savedatos( request, fila ):
            info = "Guardado"
        else:
            info = "Error"

    datos = setdatos( request )
    context.update( {'datos' : datos, } )

    context.update( {'info' : info} )

    context_instance = RequestContext( request )
    return render_to_response( 'validaruniv.html', context,
                              context_instance = context_instance )

def setdatos( request ):
    region = Region.objects.get( administrador = request.user.id )
    universidad = Universidad_temp.objects.filter( region = region )
    user = User.objects.filter( is_active = 0 )

    datos = ''

    if universidad.count() == 0:
        datos += '<h3>No existen Universidades para validar en este momento.</h3>'
    else:
        datos += '<p>Seleccione a la Universidad que quiere Validar</p>'
        datos += '<table border="0" ALIGN="CENTER" WIDTH="100%" CELLPADDING="5" class="table table-striped">'
        datos += u'<tr ALIGN="CENTER"><th>Universidad</th><th>Usuario</th><th>Información</th><th>Aceptar</th><th>Rechazar</th><th></th></tr>'

        for univ in universidad:
            for u in user:
                if univ.administrador.id == u.id:

                    datos += '<form id= "form_' + unicode( univ.id ) + '_' + unicode( u.id ) + '" action="/plataforma/validar/' + unicode( univ.administrador.id ) + '/" method="POST" class="form-horizontal">'
                    datos += '<tr ALIGN="CENTER"><td width="26%">' + unicode( univ.nombre ) + '</td>'
                    datos += '<td ALIGN="CENTER" width="26%">' + unicode( u.last_name ) + ', ' + unicode( u.first_name ) + '</td>'
                    datos += u'<td ALIGN="CENTER" width="20%"><a href="#" onclick="toggle_visibility_id(\'tabla_' + unicode( univ.id ) + '\');" id = "verInfo">Ver Info</a></td>'
                    datos += '<td width="10%" ALIGN="CENTER"><input type="radio" name="' + unicode( univ.id ) + '_' + unicode( u.id ) + '" value=1 requiere></td>'
                    datos += '<td width="10%" ALIGN="CENTER"><input type="radio" name="' + unicode( univ.id ) + '_' + unicode( u.id ) + '" value=0 requiere></td>'
                    datos += '<td width="10%"><center><button type="button" class="btn btn-primary" onClick="checkoption(\'' + unicode( 'form_' + unicode( univ.id ) + '_' + unicode( u.id ) ) + '\',\'' + unicode( univ.id ) + '_' + unicode( u.id ) + '\')">Validar</button></center></td>'
                    datos += '</form></tr>'

        datos += '</table>'

        datos += setDatosExtras( request )


    return datos

def setDatosExtras( request ):
    region = Region.objects.get( administrador = request.user.id )
    universidad = Universidad_temp.objects.filter( region = region )
    user = User.objects.filter( is_active = 0 )

    datos = ''

    if universidad.count() == 0:
        datos += '<h3>No existen Universidades para validar en este momento.</h3>'
    else:
        for univ in universidad:
            for u in user:
                if univ.administrador.id == u.id:
                    datos += '<div id="tabla_' + unicode( univ.id ) + '" style="display: none;" class="datosExtras"><hr>'
                    datos += '<table border="0" ALIGN="CENTER" WIDTH="100%" CELLPADDING="5" class="table table-striped">'
                    datos += u'<tr ALIGN="CENTER"><th>Universidad</th><th>Teléfono</th><th>Siglas</th><th>Direccion</th></tr>'
                    datos += '<tr ALIGN="CENTER"><td width="20%">' + unicode( univ.nombre ) + '</td>'
                    datos += '<td ALIGN="CENTER" width="20%">' + unicode( univ.telefono ) + '</td>'
                    datos += '<td ALIGN="CENTER" width="20%">' + unicode( univ.siglas ) + '</td>'
                    datos += '<td ALIGN="CENTER" width="20%">' + unicode( univ.direccion ) + '</td></tr>'
                    datos += '<tr ALIGN="CENTER"><td colspan="4"><a href="' + unicode( univ.url ) + '"  target="_blank">' + unicode( univ.url ) + '</a></td></tr>'
                    datos += '</table>'
                    datos += '</div>'

    return datos


def savedatos( request, fila ):
    region = Region.objects.get( administrador = request.user.id )
    univ = Universidad_temp.objects.get( administrador = fila )
    u = User.objects.get( pk = fila )
    grupo_Admin_Inst = Group.objects.get( name = "Adm. Institucional" )
    grupo_Identificado = Group.objects.get( name = "Identificado" )


    if not region.id == univ.region.id:
        return False

    try:
        # Se verifica por medio del id que el checkBox en la columna de aceptacion esta marcado
        if request.POST.has_key( unicode( univ.id ) + '_' + unicode( u.id ) ):
            if request.POST[unicode( univ.id ) + '_' + unicode( u.id )] == '1':
                # se permite al user el acceso al sistema
                u.is_active = True
                u.save()

                # Se hace una copia de los datos almacenados en la tabla Universidad_temp
                universidad = Universidad()
                universidad.nombre = univ.nombre
                universidad.telefono = univ.telefono
                universidad.url = univ.url
                universidad.siglas = univ.siglas
                universidad.pais = univ.pais
                universidad.direccion = univ.direccion
                universidad.region = univ.region
                universidad.administrador = univ.administrador

                # se guardan los datos en la tabla Universidad
                universidad.save()

                # se crea la relacion Usuario (user y universidad)
                universidad_aux = Universidad.objects.get( id = universidad.id )
                usuario = Usuario( user = u, universidad = universidad_aux )
                usuario.save()

                # se borra la fila de la tabla Universidad_temp
                univ.delete()

                # Se recupera la informacion del User recien creado, para agregarlo a un nuevo grupo
                user_group = User.objects.get( email = u.email )

                # Se le asigna a los grupos Identificado y Adm. Institucional
                grupo_Admin_Inst.user_set.add( user_group )
                grupo_Identificado.user_set.add( user_group )

                # asunto = 'Inscripción de Universidad a VinculaEntorno'
                # mensaje = """Felicitaciones!.
                # Ha sido aceptado como miembro activo de la plataforma VinculaEntorno. Ahora puede ingresar desde la página principal con su dirección de correo y contraseña.
                # Saludos Cordiales.
                # Equipo Administrativo."""
                # recipients2 = []
                # recipients = ['evincula@gmail.com']

                # Arma el correo con los datos, recipents puede ser modificado para poner el correo del encargado de responder consultas, con el header reply to facilita la respuesta a correos
                # correo = EmailMessage( asunto, mensaje, 'evincula@gmail.com', recipients2, recipients, headers = {} )

                recipients = []
                recipients.append(u.email)

                send_mail( 'Inscripción de Universidad a VinculaEntorno',
                """Felicitaciones!.
                Ha sido aceptado como miembro activo de la plataforma VinculaEntorno. Ahora puede ingresar desde la página principal con su dirección de correo y contraseña.
                Saludos Cordiales.
                Equipo Administrativo.""",
                     'evincula@gmail.com',
                     recipients,
                     fail_silently = False )

            # Se verifica por medio del id que el checkBox en la columna de rechazo esta marcado
            else:
                rechazo = request.POST['mensaje']
                recipients = []
                recipients.append(u.email)

                send_mail( 'Inscripción de Universidad a VinculaEntorno',
                """Lo sentimos, pero su solicitud ha sido rechazada.
                Los motivos fueron: """ + unicode( rechazo ) + """
                Comuniquese con el emisor de este mensaje.
                Muchas gracias.""",
                     'evincula@gmail.com',
                     recipients,
                     fail_silently = False )

                # asunto = 'Inscripción de Universidad a VinculaEntorno'
                # mensaje = 'Inscripción de Universidad a VinculaEntorno'
                # """Lo sentimos, pero su solicitud ha sido rechazada.
                # Los motivos fueron: """ + unicode( rechazo ) + """
                # Comuniquese con el emisor de este mensaje.
                # Muchas gracias."""
                # recipients2 = []
                # recipients = ['georgiodom08@gmail.com']

                # Arma el correo con los datos, recipents puede ser modificado para poner el correo del encargado de responder consultas, con el header reply to facilita la respuesta a correos
                # correo = EmailMessage( asunto, mensaje, 'evincula@gmail.com', recipients2, recipients, headers = {} )

                # Se borra del sistema la fila de la universidad que intento registrarse de la tabla Universidad_temp
                univ.delete()

                # Se borra del sistema la fila del user que se intento registrar con la universidad
                u.delete()

    except Exception, e:
        print( e )
        return False

    return True

def ajax_univ_request( request ):
    # Expect an auto 'type' to be passed in via Ajax and POST
    if request.is_ajax() and request.method == 'POST':
        opciones = '<option selected="selected" disabled="disabled" value="">| Elije una Universidad |</option>'
        universidad = Universidad.objects.filter( pais = request.POST.get( 'pais', '' ) )
        # nombre = pais.nombre.all() # get all the colors for this type of auto.
        if universidad:
            for u in universidad:
                opciones += '<option value=' + unicode( u.id ) + '>' + unicode( u.nombre ) + '</option>'
    return HttpResponse( opciones )

def index( request ):
    url = request.get_full_path()
    universidades = Universidad.objects.all()
    regiones = Region.objects.all()

    lista_sinc_paises = listarPaises( modelo = "Pais_region" )

    if request.user.is_authenticated():
        return redirect( '/plataforma/home' )

    menu = sidebar( request )

    context = Context( {
        'url': url,
        'universidades': universidades,
        'menu' : menu,
        'lista_sinc_paises': lista_sinc_paises,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'index.html', context,
                              context_instance = context_instance )


def contacto( request ):
    url = request.get_full_path()
    menu = sidebar( request )
    superuser = [user for user in User.objects.all() if user.is_superuser]
    superuser = superuser[0]

    context = Context( {
        'url': url,
        'superuser': superuser,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'contacto.html', context,
                              context_instance = context_instance )


def ayuda( request ):
    url = request.get_full_path()
    is_adm_institucional = request.user.groups.filter( 
        name = 'Adm. Institucional' ).exists()
    menu = sidebar( request )
    context = Context( {
        'url': url,
        'is_adm_institucional': is_adm_institucional,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'ayuda.html', context,
                              context_instance = context_instance )


def reportes( request ):

    if checkpermiso( request.user, Permisos ):
        # return redirect('/plataforma')
        return HttpResponse( respuestahttp() )

    regiones = Region.objects.all()
    url = request.get_full_path()

    lista_sinc_paises = listarPaises( modelo = "Pais_region" )
    menu = sidebar( request )
    context = Context( {
        'url': url,
        'regiones': regiones,
        'lista_sinc_paises': lista_sinc_paises,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'reportes.html', context,
                              context_instance = context_instance )


def reportesgenerales( request ):

    if checkpermiso( request.user, Permisos ):
        # return redirect('/plataforma')
        return HttpResponse( respuestahttp() )

    regiones = Region.objects.all()
    url = request.get_full_path()


    lista_sinc_paises = listarPaises( modelo = "Pais_region" )
    menu = sidebar( request )
    context = Context( {
        'url': url,
        'regiones': regiones,
        'lista_sinc_paises': lista_sinc_paises,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'reportesgenerales.html', context,
                              context_instance = context_instance )

def reportesregionales( request ):

    if checkpermiso( request.user, Permisos ):
        # return redirect('/plataforma')
        return HttpResponse( respuestahttp() )

    regiones = Region.objects.all()
    url = request.get_full_path()

    lista_sinc_paises = listarPaises( modelo = "Pais_region" )
    menu = sidebar( request )
    context = Context( {
        'url': url,
        'regiones': regiones,
        'lista_sinc_paises': lista_sinc_paises,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'reportesregionales.html', context,
                              context_instance = context_instance )

def reportespais( request ):

    if checkpermiso( request.user, Permisos ):
        # return redirect('/plataforma')
        return HttpResponse( respuestahttp() )

    regiones = Region.objects.all()
    url = request.get_full_path()

    universidades = Universidad.objects.all()
    lista_de_paises = []
    nombre_de_paises = []
    bandera_de_paises = []
    for universidad in universidades:
        lista_de_paises.append( universidad.pais )
        nombre_de_paises.append( universidad.pais.name )
        bandera_de_paises.append( universidad.pais.flag )

    # Codigo y nombre de pais 'en el mismo orden' en dos lista
    lista_de_paises = unicos_manteniendo_orden( lista_de_paises )
    nombre_de_paises = unicos_manteniendo_orden( nombre_de_paises )
    bandera_de_paises = unicos_manteniendo_orden( bandera_de_paises )
    # Sincronizar ambas listas
    lista_sinc_paises = zip( lista_de_paises, nombre_de_paises, bandera_de_paises )
    menu = sidebar( request )
    context = Context( {
        'url': url,
        'regiones': regiones,
        'lista_sinc_paises': lista_sinc_paises,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'reportespais.html', context,
                              context_instance = context_instance )

def actividades( request ):
    return render( request, 'actividades.html' )


def participantes( request ):
    regiones = Region.objects.all()
    universidades = Universidad.objects.all()
    url = request.get_full_path()
    menu = sidebar( request )
    if checkpermiso( request.user, Permisos2 ):
        links = False
    else:
        links = True

    context = Context( {
        'regiones': regiones,
        'universidades': universidades,
        'url': url,
        'menu' : menu,
        'links' : links,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'participantes.html', context,
                              context_instance = context_instance )

def perfil( request, perfil ):

    read_more = ""
    inicio = ''
    fin = ''

    try:
        universidad = Universidad.objects.get( pk = perfil )
    except Universidad.DoesNotExist:
        raise Http404

    if checkuniversidad( request.user, universidad, Permisos2 ):
        # return redirect('/plataforma/participantes/')
        return HttpResponse( respuestahttp() )

    region = Region.objects.get( pk = universidad.region.pk )
    administrador = User.objects.get( pk = universidad.administrador.pk )

    url = request.get_full_path()

    # Lista los informes por fecha descendente
#    informes = InformeInstitucional.objects.filter(
#        universidad_id=universidad.id).order_by("-fecha")
    mas_de_un_informe = False
    try:
        datos_indicadores_texto = RespuestaTexto.objects.filter( universidad_id = universidad.id ).order_by( '-fecha_fin' )
        if datos_indicadores_texto.count() == 0:
            datos_indicadores_texto = False
        else:
            if datos_indicadores_texto.count() > 1:
                mas_de_un_informe = True
            datos_indicadores_texto = datos_indicadores_texto[0]
            inicio = datos_indicadores_texto.fecha_inicio.strftime( "%d-%m-%Y" )
            fin = datos_indicadores_texto.fecha_fin.strftime( "%d-%m-%Y" )
    except RespuestaTexto.DoesNotExist:
        datos_indicadores_texto = False


    if datos_indicadores_texto:
        datos_indicadores_booleanos = RespuestaBooleanos.objects.filter( universidad_id = universidad.id , fecha_fin = datos_indicadores_texto.fecha_fin )

        datos_indicadores_choices = RespuestaChoices.objects.filter( universidad_id = universidad.id , fecha_fin = datos_indicadores_texto.fecha_fin )

        datos_indicadores_enteros = RespuestaEnteros.objects.filter( universidad_id = universidad.id , fecha_fin = datos_indicadores_texto.fecha_fin )

        datos_indicadores_porcentaje = RespuestaPorcentaje.objects.filter( universidad_id = universidad.id , fecha_fin = datos_indicadores_texto.fecha_fin )


        respuestas_boolean = ( 'No', 'Si', 'No aplica' )
        respuestas_choices = ( 'Mala', 'Buena', 'Muy Buena', 'Excelente', 'No aplica' )
        read_more = ""

        for i in range( 1, 4 ):
            if i == 1:
                read_more += "<h3>Formacion Continua </h3><br/>"
            elif i == 2:
                read_more += "<h3>Tranferencia del conocimiento </h3><br/>"
            elif i == 3:
                read_more += "<h3>Compromiso social  </h3><br/>"
            for elemento in datos_indicadores_booleanos:
                etiqueta_indicador = IndicadoresBooleanos.objects.get( id = elemento.indicador_id )
                if etiqueta_indicador.dimension == i:
                    read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + respuestas_boolean[int( elemento.respuesta )] + "</b></p>"
            for elemento in datos_indicadores_choices:
                etiqueta_indicador = IndicadoresChoices.objects.get( id = elemento.indicador_id )
                if etiqueta_indicador.dimension == i:
                    read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + respuestas_choices[int( elemento.respuesta ) - 1] + "</b></p>"
            for elemento in datos_indicadores_enteros:
                etiqueta_indicador = IndicadoresEnteros.objects.get( id = elemento.indicador_id )
                if etiqueta_indicador.dimension == i:
                    if elemento.respuesta < 0:
                        read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + 'No aplica' + "</b></p>"
                    else:
                        read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + unicode( elemento.respuesta ) + "</b></p>"
            for elemento in datos_indicadores_porcentaje:
                etiqueta_indicador = IndicadoresPorcentaje.objects.get( id = elemento.indicador_id )
                if etiqueta_indicador.dimension == i:
                    if elemento.respuesta < 0:
                        read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + 'No aplica' + "</b></p>"
                    else:
                        read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + unicode( elemento.respuesta ) + "</b></p>"


    menu = sidebar( request )
    context = Context( {
        'universidad': universidad,
        'region': region,
        'administrador': administrador,
        'url': url,
        # 'informes': informes,
        'read_more': read_more,
        'datos_indicadores_texto': datos_indicadores_texto,
        'menu' : menu,
        'inicio' : inicio,
        'fin': fin,
        'mas_de_un_informe' : mas_de_un_informe,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'perfil.html', context,
                              context_instance = context_instance )


@login_required( login_url = '/plataforma/' )
def home( request ):
    url = request.get_full_path()
    regiones = Region.objects.all()

    is_adm_institucional = getAdminIns( request )
    is_adm_regional = request.user.groups.filter( name = 'Adm. Regional' ).exists()
    is_admin = request.user.is_superuser

    menu = sidebar( request )

    message = ''
    if 'message' in request.GET:
        message = request.GET['message']

    if is_adm_institucional:
        universidad = Universidad.objects.get( administrador_id = request.user.id )

        context = Context( {
            'is_adm_institucional' : True,
            'is_adm_regional' : False,
            'is_admin' : False,
            'url': url,
            'regiones': regiones,
            'menu' : menu,
            'message' : message,
            'universidad' : universidad,
        } )

        if is_adm_regional:
            context = Context( {
                'is_adm_institucional' : True,
                'is_adm_regional' : True,
                'is_admin' : False,
                'url': url,
                'regiones': regiones,
                'menu' : menu,
                'message' : message,
                'universidad' : universidad,
            } )
    else:
        context = Context( {
            'is_adm_institucional' : False,
            'is_adm_regional' : False,
            'url': url,
            'regiones': regiones,
            'menu' : menu,
            'message' : message,
        } )

    if is_admin:
        context = Context( {
            'is_adm_institucional' : False,
            'is_adm_regional' : False,
            'is_admin' : True,
            'url': url,
            'regiones': regiones,
            'menu' : menu,
            'message' : message,
        } )

    context_instance = RequestContext( request )
    return render_to_response( 'home.html', context,
                              context_instance = context_instance )


@login_required( login_url = '/plataforma/' )
def homeredirect( request ):
    url = request.get_full_path()
    regiones = Region.objects.all()
    menu = sidebar( request )
    context = Context( {
        'redireccionar_home': True,
        'url': url,
        'regiones': regiones,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'home.html', context,
                              context_instance = context_instance )


def login_( request ):
    login_error = False
    no_aceptado = False

    if request.POST:
        username = request.POST['email']
        password = request.POST['password']

        user = authenticate( username = username, password = password )

        if user is not None:
            if not user.is_active:
                no_aceptado = True;
            else:
                login( request, user )
                return redirect( '/plataforma/home/' )
        else:
            login_error = True

    universidades = Universidad.objects.all()
    menu = sidebar( request )
    context = Context( {
        'no_aceptado': no_aceptado,
        'login_error': login_error,
        'registro_error': False,
        'universidades': universidades,
        'menu' : menu,
    } )

    context_instance = RequestContext( request )
    return render_to_response( 'index.html', context,
                              context_instance = context_instance )


def logout_( request ):
    logout( request )
    return redirect( '/plataforma/' )


def unicos_manteniendo_orden( lista ):
    resultado = []
    for elemento in lista:
        if elemento in resultado:
            continue
        resultado.append( elemento )
    return resultado

# crear el menu de acuerdo a permisos de usuarios
def sidebar( request ):
    url = request.get_full_path()
    is_adm_institucional = getAdminIns( request )
    is_adm_regional = request.user.groups.filter( name = 'Adm. Regional' ).exists()

    menu = ''

    if not checkpermiso( request.user, Permisos ):
        menu += """
            <div id='cssmenu'>
                <ul>
                   <li class='active'><a><span><i class="icon-th-list icon-white"></i> &nbsp;  Menu Principal</span></a></li>
                   <li class='has-sub'><a href='#'><span>Reportes</span></a>
                      <ul>
                         <li><a href='/plataforma/reportesgenerales/'><span>Generales</span></a></li>
                         <li class='last'><a href='/plataforma/reportesregionales/'><span>Paises</span></a></li>
                      </ul>
                   </li>
                   <li><a href='/plataforma/participantes/'><span>Participantes</span></a></li>
                   <li><a href='/plataforma/buenaspracticas/lista_completa/'><span>Buenas prácticas</span></a></li>
                   <li class='last'><a href='/plataforma/vista_publica_informes_pais/'><span>Informes de paises</span></a></li>
                </ul>
                <br><br>
            """


    if request.user.is_staff or is_adm_institucional or is_adm_regional:


        menu += """
            <ul>
                <li class='active'><a><span><i class="icon-wrench icon-white"></i> &nbsp; Administracion</span></a></li>
        """
        if is_adm_institucional:

            hay_informe_anterior = False
            universidad_en_cuestion = Universidad.objects.get( administrador = request.user )
            informe_anterior = RespuestaTexto.objects.filter( universidad = universidad_en_cuestion )

            if informe_anterior.count() > 0:
                hay_informe_anterior = True

            menu += """
               <li class='has-sub'><a href='#'><span>Adm. Institucional</span></a>
                    <ul>
                        <li class='has-sub'><a href='#'><span>Informe de indicadores 3M</span></a>
                    <ul>
                    <li><a href='/plataforma/indicadores/formulario/1/0/'><span>Cargar nuevo informe</span></a></li>
            """
            if hay_informe_anterior:
                menu += "<li class='last'><a href='/plataforma/indicadores/listar_informes_anteriores/" + str( universidad_en_cuestion.id ) + "/'><span>Listar informes</span></a></li>"

            menu += """
                    </ul>
                </li>
                <li class='has-sub'><a href='#'><span>Formulario de buenas prácticas</span></a>
                    <ul>
                        <li><a href='/plataforma/buenaspracticas/agregar/'><span>Agregar buenas prácticas</span></a></li>
                        <li class='last'><a href='/plataforma/buenaspracticas/listar/'><span>Listar/Editar Buenas Prácticas</span></a></li>
                    </ul>
                </li>
                </li>
                    <li class='last'><a href='/plataforma/usuarios/administrar'><span>Administrar Usuarios</span></a></li>
                </li>
                    <li class='last'><a href='/plataforma/usuarios/validar/'><span>Validar nuevos usuarios</span></a></li>
                </li>
                </li>
                    <li class='last'><a href='/plataforma/usuarios/editaruniversidad'><span>Editar datos de la Universidad</span></a></li> 
                </li>
            </ul>
            """
        if is_adm_regional:
            menu += """
                <li class='has-sub'><a href='#'><span>Adm. Regional</span></a>
                    <ul>
                        <li><a href='/plataforma/validar/'><span>Validar nueva universidad</span></a></li>
                        <li class='last'><a href='/plataforma/listar_informes_pais/'><span>Administrar informe país</span></a></li>
                    </ul>
                </li>
            """
        if request.user.is_staff:
            menu += """
   <li class='has-sub last'><a href='#'><span>Super - Administración</span></a>
      <ul>
         <li><a href='/plataforma/universidades/admin_user'><span>Usuarios</span></a></li>
         <li><a href='/plataforma/universidades/admin_region'><span>Regiones</span></a></li>
         <li><a href='/plataforma/universidades/admin_universidades'><span>Universidades</span></a></li>
         <li><a href='/plataforma/indicadores/administrar'><span>Indicadores</span></a></li>
         <li><a href='/plataforma/permisos/'><span>Asignar permisos</span></a></li>
      </ul>
   </li>
</ul>

"""
    menu += "</div>"




#     menu = ""
#     menu += '<li class="nav-header">Menu</li>'
#     if not checkpermiso( request.user, Permisos ):
#         menu += '<li class="dropdown"><a id="drop1" href="#" role="button" class="dropdown-toggle" data-toggle="dropdown">Reportes<b class="caret"></b></a>'
#         menu += '<ul id="reportes"class="dropdown-menu" role="menu" aria-labelledby="drop1">'
#         menu += '<li role="presentation"><a role="menuitem" tabindex="-1" href="/plataforma/reportesgenerales/">Generales</a></li>'
#         menu += '<li role="presentation"><a role="menuitem" tabindex="-1" href="/plataforma/reportesregionales/">Regionales</a></li>'
#         menu += '<li role="presentation"><a role="menuitem" tabindex="-1" href="/plataforma/reportespais/">País</a></li>'
#         menu += '</ul></li>'
#
#     if url == '/plataforma/participantes/':
#         menu += '<li class="active"><a href="/plataforma/participantes/">Participantes</a></li>'
#     else:
#         menu += '<li><a href="/plataforma/participantes/">Participantes</a></li>'
#
#     if url == '/plataforma/buenaspracticas/lista_completa/':
#         menu += '<li class="active"><a href="/plataforma/buenaspracticas/lista_completa/">Buenas Practicas</a></li>'
#     else:
#         menu += '<li><a href="/plataforma/buenaspracticas/lista_completa/">Buenas Practicas</a></li>'
#
#     if not checkpermiso( request.user, ['validaciones.Participantes_Publico'] ):
#         if url == '/plataforma/vista_publica_informes_pais/':
#             menu += '<li class="active"><a href="/plataforma/vista_publica_informes_pais/">Informes de paises</a></li>'
#         else:
#             menu += '<li><a href="/plataforma/vista_publica_informes_pais/">Informes de paises</a></li>'
#
# #     if request.user.is_staff or is_adm_institucional or is_adm_regional:
# #         menu += '<li class="divider"></li><li class="nav-header">Administración</li>'
#
#     if is_adm_regional:
#         menu += '<li class="divider"></li><li class="nav-header">Administración Regional</li>'
#         menu += '<li class="divider"></li><li class="nav-header">Validaciones</li>'
#         if url == '/plataforma/validar/':
#             menu += ' <li class="active"><a href="/plataforma/validar/">Validar nueva universidad</a></li>'
#         else:
#             menu += ' <li><a href="/plataforma/validar/">Validar nueva universidad</a></li>'
#
#         menu += '<li class="divider"></li><li class="nav-header">Informes de paises</li>'
#         if url == '/plataforma/listar_informes_pais/':
#             menu += ' <li class="active"><a href="/plataforma/listar_informes_pais/">Administrar informe pais</a></li>'
#         else:
#             menu += ' <li><a href="/plataforma/listar_informes_pais/">Administrar informe pais</a></li>'
#
#     if is_adm_institucional:
#         menu += '<li class="divider"></li><li class="nav-header">Administración Institucional</li>'
#         menu += '<li class="divider"></li><li class="nav-header">Validaciones</li>'
#         if url == '/plataforma/usuarios/validar/':
#             menu += ' <li class="active"><a href="/plataforma/usuarios/validar/">Validar nuevos Usuarios</a></li>'
#         else:
#             menu += ' <li><a href="/plataforma/usuarios/validar/">Validar nuevos Usuarios</a></li>'
#         menu += '<li class="divider"></li><li class="nav-header">Administración Institucional</li>'
#         menu += '<li class="divider"></li><li class="nav-header">Formulario de indicadores</li>'
#         if url == '/plataforma/informes/formulario/':
#             if hay_informe_anterior:
#                 menu += '<li><a href="/plataforma/indicadores/formulario/0">Editar informe indicadores</a></li>'
#                 menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#             else:
#                 menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#             menu += '<li><a href="/plataforma/actividades/listado/">Actividades</a><br></li>'
#         else:
#             if url == '/plataforma/actividades/listado/':
#                 if hay_informe_anterior:
#                     menu += '<li><a href="/plataforma/indicadores/formulario/0">Editar informe indicadores</a></li>'
#                     menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#                 else:
#                     menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#                 menu += '<li class="active"><a href="/plataforma/actividades/listado/">Actividades</a><br></li>'
#             else:
#                 if url == '/plataforma/indicadores/formulario/':
#                     if hay_informe_anterior:
#                         menu += '<li><a href="/plataforma/indicadores/formulario/0">Editar informe indicadores</a></li>'
#                         menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#                     else:
#                         menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#                     menu += '<li><a href="/plataforma/actividades/listado/">Actividades</a><br></li>'
#                 else:
#                     if hay_informe_anterior:
#                         menu += '<li><a href="/plataforma/indicadores/formulario/0">Editar informe indicadores</a></li>'
#                         menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#                     else:
#                         menu += '<li><a href="/plataforma/indicadores/formulario/1">Cargar informe indicadores</a></li>'
#                     menu += '<li><a href="/plataforma/actividades/listado/">Actividades</a><br></li>'
#         menu += '<li class="divider"></li><li class="nav-header">Formulario de Buenas Practicas</li>'
#         menu += '<li><a href="/plataforma/buenaspracticas/agregar/">Agregar Buenas Practicas</a></li>'
#         menu += '<li><a href="/plataforma/buenaspracticas/listar/">Listar/Editar Buenas Practicas</a></li>'
#
#
#     if request.user.is_staff:
#         menu += '<li class="divider"></li><li class="nav-header">Super - Administración</li>'
#         menu += '<li><a href="/plataforma/universidades/admin_user">Usuarios</a></li>'
#         menu += '<li><a href="/plataforma/universidades/admin_region">Regiones</a></li>'
#         menu += '<li><a href="/plataforma/universidades/admin_universidades">Universidades</a></li>'
#         menu += '<li class="divider"></li><li class="nav-header">Indicadores</li>'
#         menu += '<li><a href="/plataforma/indicadores/administrar">Listar indicadores</a></li>'
#         menu += '<li class="divider"></li><li class="nav-header">Asignaciones</li>'
#         menu += '<li><a href="/plataforma/universidades/admin_pais_region">Asignar regiones</a></li>'
#         if url == '/plataforma/permisos/':
#             menu += '<li class="active"><a href="/plataforma/permisos/">Asignar permisos</a></li>'
#         else:
#             menu += '<li><a href="/plataforma/permisos/">Asignar Permisos</a></li>'

    return menu

def pagpermisos( request ):
    if not request.user.is_staff:
        return HttpResponse( respuestahttp() )

    menu = sidebar( request )
    context = Context( {
        'menu' : menu,
    } )
    info = "Iniciado"
    if request.method == 'POST':
        if savepermisos( request ):
            info = "Guardado"
        else:
            info = "Error"
            permi = setpermi()
    else:
        permi = setpermi()
        context.update( {'permi':permi, } )

    context.update( {'info' : info} )

    context_instance = RequestContext( request )
    return render_to_response( 'permisos.html', context,
                              context_instance = context_instance )

def setpermi():
    aux = Validacion()
    dummy_user = User.objects.get( username = "Anonimo" )
    permi = ''
    for iten in aux._meta.permissions:
        permi += '<tr ALIGN="CENTER"><td>' + unicode( iten[1] ) + '</td>'
        if dummy_user.has_perm( 'validaciones.' + unicode( iten[0] ) ):
            permi += '<td><input type="checkbox" name="An_' + unicode( iten[0] ) + '" value="1" checked></td>'
        else:
            permi += '<td><input type="checkbox" name="An_' + unicode( iten[0] ) + '" value="1"></td>'
        grupo = Group.objects.get( name = "Identificado" )
        permisosgrupo = grupo.permissions.all()
        if  permisosgrupo.__contains__( Permission.objects.get( name = unicode( iten[1] ) ) ):
            permi += '<td><input type="checkbox" name="Id_' + unicode( iten[0] ) + '" value="1" checked></td>'
        else:
            permi += '<td><input type="checkbox" name="Id_' + unicode( iten[0] ) + '" value="1"></td>'
        grupo = Group.objects.get( name = "Adm. Institucional" )
        permisosgrupo = grupo.permissions.all()
        if  permisosgrupo.__contains__( Permission.objects.get( name = unicode( iten[1] ) ) ):
            permi += '<td><input type="checkbox" name="In_' + unicode( iten[0] ) + '" value="1" checked></td>'
        else:
            permi += '<td><input type="checkbox" name="In_' + unicode( iten[0] ) + '" value="1"></td>'
        grupo = Group.objects.get( name = "Adm. Regional" )
        permisosgrupo = grupo.permissions.all()
        if  permisosgrupo.__contains__( Permission.objects.get( name = unicode( iten[1] ) ) ):
            permi += '<td><input type="checkbox" name="Re_' + unicode( iten[0] ) + '" value="1" checked></td>'
        else:
            permi += '<td><input type="checkbox" name="Re_' + unicode( iten[0] ) + '" value="1"></td>'
        permi += '</tr>'
    return permi

def savepermisos( request ):
    aux = Validacion()
    dummy_user = User.objects.get( username = "Anonimo" )
    try:

        for iten in aux._meta.permissions:

            if request.POST.has_key( 'An_' + unicode( iten[0] ) ):
                dummy_user.user_permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                grupo = Group.objects.get( name = "Identificado" )
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                grupo = Group.objects.get( name = "Adm. Institucional" )
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                grupo = Group.objects.get( name = "Adm. Regional" )
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                continue
            else:
                dummy_user.user_permissions.remove( Permission.objects.get( name = unicode( iten[1] ) ) )

            grupo = Group.objects.get( name = "Identificado" )
            if request.POST.has_key( 'Id_' + unicode( iten[0] ) ):
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                grupo = Group.objects.get( name = "Adm. Institucional" )
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                grupo = Group.objects.get( name = "Adm. Regional" )
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
                continue
            else:
                grupo.permissions.remove( Permission.objects.get( name = unicode( iten[1] ) ) )

            grupo = Group.objects.get( name = "Adm. Institucional" )
            if request.POST.has_key( 'In_' + unicode( iten[0] ) ):
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
            else:
                grupo.permissions.remove( Permission.objects.get( name = unicode( iten[1] ) ) )

            grupo = Group.objects.get( name = "Adm. Regional" )
            if request.POST.has_key( 'Re_' + unicode( iten[0] ) ):
                grupo.permissions.add( Permission.objects.get( name = unicode( iten[1] ) ) )
            else:
                grupo.permissions.remove( Permission.objects.get( name = unicode( iten[1] ) ) )

    except Exception:
        return False
    return True


#*****************************************Validaciones en tiempo real*******************************************************
# Tanto del email del user como de la URL de la universidad, se verifica que no exista un duplicado en la BD
@csrf_exempt
def ajax_message_email( request ):
    if request.is_ajax() and request.method == 'POST':
        email = request.POST['email']
        message = ''
        if ( User.objects.filter( username = unicode( email ) ).exists() ):
            message = "El correo ingresado ya existe. Ingrese uno diferente."
            tipo = "error"
        else:
            message = "El correo ingresado es correcto."
            tipo = "exito"
        to_json = {'message':message, 'tipo':tipo}
        return HttpResponse( simplejson.dumps( to_json ), mimetype = 'application/json' )

@csrf_exempt
# formatos aceptados http://www..., https://www..., www...
def ajax_message_url( request ):
    if request.is_ajax() and request.method == 'POST':
        url_aux = []
        url = request.POST['url']
        # parseamos la url para obtener solo la parte del www...
        url_aux = url.split( '//' )
        if len( url_aux ) == 1:  # la url ingresada es del tipo www... entonces se le pasa ese valor del vector en [0]
            url_a_verificar = url_aux[0]
        elif len( url_aux ) == 2:  # la url ingresada es del tipo http://www... o https://www..., por eso le pasamos el segundo valor del vector ([1]) al hacer el split, que seria la parte del wwww..
            url_a_verificar = url_aux[1]
        message = ''
        if ( Universidad.objects.filter( url = unicode( url_a_verificar ) ).exists() ):
            message = "La URL ingresada ya existe. Ingrese uno diferente."
            tipo = "error"
        else:
            message = "La URL ingresada es correcta."
            tipo = "exito"
        to_json = {'message':message, 'tipo':tipo}
        return HttpResponse( simplejson.dumps( to_json ), mimetype = 'application/json' )

#*****************************************formulario_universidad_user*******************************************************
def validar_formulario_universidad_user( request ):
    lista_sinc_paises = listarPaises( modelo = "Pais_region" )
    regiones = Region.objects.all()
    menu = sidebar( request )
    show_message_success = False
    show_message_error = False
    mensaje_error = ''
    mensaje_exito = ''
    if request.method == 'POST':
        email = request.POST['email_admin_univ']
        password = request.POST['password_admin_univ']
        confirm = request.POST['confirmacion_admin_univ']
        nombre = unicode( request.POST['nombreUniv_admin_univ'] )
        url = unicode( request.POST['url_admin_univ'] )
        pais = request.POST['pais_admin_univ']
        telefono = ''
        telefono_completo = ''
        cod_pais = ''
        cod_ciudad = ''
        direccion = ''
        siglas = ''

        # verificamos si estos datos existen o no, puesto que no son campos requeridos
        if 'siglas_admin_univ' in request.POST:
            siglas = unicode( request.POST['siglas_admin_univ'] )

        if 'direccion_admin_univ' in request.POST:
            direccion = unicode( request.POST['direccion_admin_univ'] )

        if 'telefono_admin_univ' in request.POST:
            telefono = unicode( request.POST['telefono_admin_univ'] )

        if 'cod_pais_admin_univ' in request.POST:
            cod_pais = unicode( request.POST['cod_pais_admin_univ'] )

        if 'cod_ciudad_admin_univ' in request.POST:
            cod_ciudad = unicode( request.POST['cod_ciudad_admin_univ'] )

        telefono_completo = cod_pais + "-" + cod_ciudad + "-" + telefono  # reconstruimos el telefono


        ##########Validaciones del formulario#####################
        # ##Verificamos que los campos Required, no vengan vacios
        if email == '':
            mensaje_error += "<p>El campo correo no debe estar vacío."
        elif ( User.objects.filter( username = unicode( email ) ).exists() ):
            mensaje_error += "El correo ingresado ya existe. Ingrese uno diferente."
        elif not( re.match( r"^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$", email ) ):
            mensaje_error += "Verifique el formato del correo ingresado."

        if password == '':
            mensaje_error += "<p>El campo password no debe estar vacío."
        if confirm == '':
            mensaje_error += "<p>El campo confirmación no debe estar vacío."

        if  nombre == '':  # nombre Universidad
            mensaje_error += "<p>El campo nombre de universidad no debe estar vacío."
        if url == '':
            mensaje_error += "<p>El campo URL no debe estar vacío."
        elif ( Universidad.objects.filter( url = unicode( url ) ).exists() ):  # se verifica que la url ingresada no esté duplicada
            mensaje_error += "La URL ingresada ya existe. Ingrese uno diferente."
        elif not( re.match( r"^((http:\/\/www\.|https:\/\/www\.|www\.)[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*\.[a-zA-Z]{2,6}(?:\/?|(?:\/[\w\-]+)*)(?:\/?|\/\w+\.[a-zA-Z]{2,4}(?:\?[\w]+\=[\w\-]+)?)?(?:\&[\w]+\=[\w\-]+)*)$", url ) ):
            mensaje_error += "Verifique el formato de la url."

        if pais == '':
            mensaje_error += "<p>Se debe seleccionar un país para la universidad."

        if password != '' and confirm != '':  # si estos campos no vienen vacio, hay que verificar que coincidan.
            if password != confirm:
                mensaje_error += "<p>El password y la confirmación deben coincidir."

        if mensaje_error != '':  # si hubo algun error, volvemos a la pagina Agregar_User, para corregir dichos errores
            show_message_error = True
            mtx = {
                'nombre' : nombre,
                'telefono' : telefono,
                'cod_pais':cod_pais,
                'cod_ciudad':cod_ciudad,
                'url' : url,
                'pais' : pais,
                'siglas' : siglas,
                'direccion' : direccion,
                'regiones' : regiones,
                'lista_sinc_paises': lista_sinc_paises,
                'menu' : menu,
                'show_message_success': show_message_success,
                'show_message_error': show_message_error,
                'mensaje_error':mensaje_error,
                'mensaje_exito':mensaje_exito
            }

            context_instance = RequestContext( request )
            return render_to_response( 'formulario_universidad_user.html', mtx,
                          context_instance = context_instance )
        ################FORMULARIOS###############################
        # se guarda al nuevo user, se lo activa para loguearse

        user = User()
        user.first_name = request.POST['nombre_admin_univ']
        user.last_name = request.POST['apellido_admin_univ']
        user.email = email
        user.username = user.email
        user.set_password( password )
        user.is_active = True  # por defecto se envia True para que pueda logearse
        try:
            user.save()
        except Exception, e:
            return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

        user_creado = User.objects.get( email = unicode( email ) )  # Se recupera el user recien creado

        # Asignar a un grupo al nuevo user
        try:
            g = Group.objects.get( name = "Adm. Institucional" )  # por defecto es institucional
            g.user_set.add( user_creado.id )
        except Exception, e:
            return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )

        # Registramos la universidad
        region = Pais_region.objects.get( pais = pais )  # Buscamos la region a la que pertenece el pais
        respuesta = Universidad( nombre = nombre, administrador_id = user_creado.id, region_id = region.region_id, siglas = siglas, telefono = telefono_completo, url = url, pais = pais, direccion = direccion )
        try:
            respuesta.save()
        except Exception, e:
            return HttpResponse( "<h2>" + unicode( e ) + "</h2>" )


        # se crea la relacion Usuario (user y universidad)
        universidad_aux = Universidad.objects.get( url = url )
        usuario = Usuario( user = user_creado, universidad = universidad_aux )
        usuario.save()

        return redirect( '/plataforma/universidades/admin_universidades/' + "?message=La universidad ha sido creada con exito./exito" )

    else:
        return redirect( '/plataforma/universidades/admin_universidades/' )

def formulario_universidad_user( request ):
    if request.user.is_staff:
        identificador_univ = ''
        administrador = ''
        nombre = ''
        telefono = ''
        cod_pais = ''
        cod_ciudad = ''
        url = ''
        pais = ''
        direccion = ''
        siglas = ''
        lista_sinc_paises = listarPaises( modelo = "Pais_region" )
        menu = sidebar( request )
        if request.method == 'POST':
            # POST DEL formulario

            # Verificamos si los sgtes campos tienen o no valor, puesto que simplemente es una migracion de los datos ya cargados
            # en el formulario Agregar Universidad y pasarlos a formulario_universidad_user
            if 'name' in request.POST:
                nombre = unicode( request.POST['name'] )

            if 'URL' in request.POST:
                url = unicode( request.POST['URL'] )  # Se separa el http:// de la url

            if 'paises' in request.POST:
                pais = request.POST['paises']

            if 'sigla' in request.POST:
                siglas = unicode( request.POST['sigla'] )

            if 'Direccion' in request.POST:
                direccion = unicode( request.POST['Direccion'] )

            if 'telefono' in request.POST:
                telefono = unicode( request.POST['telefono'] )

            if 'cod_pais' in request.POST:
                cod_pais = unicode( request.POST['cod_pais'] )

            if 'cod_ciudad' in request.POST:
                cod_ciudad = unicode( request.POST['cod_ciudad'] )


        mtx = {
            'nombre' : nombre,
            'cod_pais':cod_pais,
            'cod_ciudad':cod_ciudad,
            'telefono' : telefono,
            'url' : url,
            'pais' : pais,
            'siglas' : siglas,
            'direccion' : direccion,
            'lista_sinc_paises': lista_sinc_paises,
            'menu' : menu
            }

        context_instance = RequestContext( request )
        return render_to_response( 'formulario_universidad_user.html', mtx,
                          context_instance = context_instance )

    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

@csrf_exempt
def ajax_user_modal( request ):
    if request.is_ajax() and request.method == 'POST':
        id_user = request.POST['id_user']
        usuario = Usuario.objects.get( user = id_user )
        universidad = Universidad.objects.get(id = usuario.universidad_id)
        user = User.objects.get(id = id_user)
        to_json = {'firstname':user.first_name, 'lastname':user.last_name, 'email':user.email, 'username':user.username, 'is_superuser':user.is_superuser, 'is_active':user.is_active, 'is_staff':user.is_staff, 'universidad':universidad.nombre}
        return HttpResponse( simplejson.dumps( to_json ), mimetype = 'application/json' )

@csrf_exempt
def ajax_universidad_modal( request ):
    if request.is_ajax() and request.method == 'POST':
        id_univ = request.POST['id_univ']
        universidad = Universidad.objects.get(id = id_univ)
        region = Region.objects.get(id = universidad.region_id)
        pais_region = Pais_region.objects.get(pais = universidad.pais)
        user = User.objects.get(id = universidad.administrador_id)
        to_json = {'nombre':universidad.nombre, 'telefono':universidad.telefono, 'url':universidad.url, 'pais':region.nombre, 'direccion':universidad.direccion, 'siglas':universidad.siglas, 'region':region.nombre, 'administrador':user.username}
        return HttpResponse( simplejson.dumps( to_json ), mimetype = 'application/json' )

@csrf_exempt
def ajax_region_modal( request ):
    if request.is_ajax() and request.method == 'POST':
        id_region = request.POST['id_region']
        region = Region.objects.get(id = id_region)
        user = User.objects.get(id = region.administrador_id)
        to_json = {'nombre':region.nombre, 'administrador':user.username}
        return HttpResponse( simplejson.dumps( to_json ), mimetype = 'application/json' )

@csrf_exempt
def ajax_eliminar_user_univ(request):
    if request.is_ajax() and request.method == 'POST':
        banderaExitoBorrado = 0
        exito = 0
        cant_Universidades_a_Borrar = 0
        mensaje = ""

        if 'universidad_id' in request.POST:
            universidad_id = request.POST['universidad_id']
            universidad = Universidad.objects.get(id = universidad_id)
            mtx = envioMailAlBorrarUniversidad(universidad_id, "Universidad")
        elif 'region_id' in request.POST:
            region_id = request.POST['region_id']
            region = Region.objects.get(id = region_id)
            mtx = envioMailAlBorrarUniversidad(region_id, "Region")

        

        if len(mtx['mensaje_universidad']) == 0: #si no hay universidades cargadas. En el caso de borrarse una region
            banderaExitoBorrado = 1
            user = User.objects.get(id = region.administrador_id)
            g = Group.objects.get( name = 'Adm. Regional' ) #si es el admin de la region a borrar, se le quita este atributo
            g.user_set.remove( user )
            mensaje = "" #<<<<<<<<<<<<COMPLETAR
            asunto = 'Baja de la plataforma'
            recipients = [unicode( user.email )]
            send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)
            region.delete()

        else:
            
            for i in range(len(mtx['mensaje_universidad'])):
                nombreUniversidad = mtx['mensaje_universidad'][i][0]
                mensaje_usuarios_institucional = mtx['mensaje_universidad'][i][1]
                mensaje_usuarios_regional = mtx['mensaje_universidad'][i][2]
                if len(mensaje_usuarios_institucional) == 0 and len(mensaje_usuarios_regional)==0: #si alguna universidad tiene usuarios adm de otra institucion o de otra region
                    cant_Universidades_a_Borrar += 1
                
                if len(mensaje_usuarios_institucional) != 0:
                    mensaje += "<p><b>>>"+nombreUniversidad+"</b></p>" 
                    mensaje += "<p><b>Usuarios como administradores Institucionales:</b>"
                    for m in mensaje_usuarios_institucional:
                        mensaje += "<p><b>**</b>"+m

                    mensaje += "<h6><i>Para eliminar la universidad, estos usuarios deben dejar de ser administradores institucionales.<p>Por favor, vaya a la universidad correspondiente, y haga el traspaso de administradores.</i></h6>"

        
                if len(mensaje_usuarios_regional) != 0: 
                    mensaje += "<p><b>Usuarios como administradores regionales:</b>"
                    for m in mensaje_usuarios_regional:
                        mensaje += "<p><b>**</b>"+m

                    mensaje += u"<h6><i>Para eliminar la universidad, estos usuarios deben dejar de ser administradores regionales.<p>Por favor, vaya a la región correspondiente, y haga el traspaso de administradores.</i></h6>"


            if cant_Universidades_a_Borrar == len(mtx['mensaje_universidad']): #todas las universidades estan sin problemas, pueden empezar a borrarse
                if 'region_id' in request.POST: # si una region fue seleccionada para ser borrada, sus universidades ya fueron eliminadas en lineas anteriores, por lo que ahora queda eliminar dicha region
                    user = User.objects.get(id = region.administrador_id)
                    g = Group.objects.get( name = 'Adm. Regional' ) #si es el admin de la region a borrar, se le quita este atributo
                    g.user_set.remove( user )
                    mensaje = "" #<<<<<<<<<<<<COMPLETAR
                    asunto = 'Baja de la plataforma'
                    recipients = [unicode( user.email )]
                    send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)
                    region.delete()

                for i in range(len(mtx['mensaje_universidad'])):
                    nombreUniversidad = mtx['mensaje_universidad'][i][0]
                    mensaje_usuarios_institucional = mtx['mensaje_universidad'][i][1]
                    mensaje_usuarios_regional = mtx['mensaje_universidad'][i][2]
                    if len(mensaje_usuarios_institucional) == 0 and len(mensaje_usuarios_regional)==0:
                        if 'universidad_id' in request.POST:
                            user = User.objects.get(id = universidad.administrador_id)
                            g = Group.objects.get( name = 'Adm. Institucional' )
                            g.user_set.remove( user )
                            mensaje = "" #<<<<<<<<<<<<COMPLETAR
                            asunto = 'Baja de la plataforma'
                            recipients = [unicode( user.email )]
                            send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)
                            universidad.delete()

                            for usuarios_aux in mtx['usuarios_a_borrar']:
                                user = User.objects.get(id = usuarios_aux.user_id)
                                mensaje = "" #<<<<<<<<<<<<COMPLETAR
                                asunto = 'Baja de la plataforma'
                                recipients = [unicode( user.email )]
                                send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)
                                user.delete()

                        elif 'region_id' in request.POST:
                            universidad = Universidad.objects.filter(region_id = region_id)
                            for universidad_aux in universidad:
                                uni = Universidad.objects.get(id = universidad_aux.id)
                                uni.delete()
                            
                            for usuarios_aux in mtx['usuarios_a_borrar']:
                                if User.objects.filter(id = usuarios_aux.user_id).exists():
                                    user = User.objects.get(id = usuarios_aux.user_id)
                                    mensaje = "" #<<<<<<<<<<<<COMPLETAR
                                    asunto = 'Baja de la plataforma'
                                    recipients = [unicode( user.email )]
                                    send_mail(asunto, mensaje, 'evincula@gmail.com', recipients)
                                    user.delete()
             


            
        if banderaExitoBorrado or (cant_Universidades_a_Borrar == (len(mtx['mensaje_universidad']))):
            if 'region_id' in request.POST:
                mensaje+="<p><b>La región ha sido eliminada exitosamente.!</b>"
            elif 'universidad_id' in request.POST:
                mensaje+="<p><b>La universidad ha sido eliminada exitosamente.!</b>"

            exito = 1
        
        to_json = {'mensaje':mensaje, 'exito':exito}
        return HttpResponse( simplejson.dumps( to_json ), mimetype = 'application/json' )

